From 6ffeb48bbb41badd65e8de6e72df0b359591dc9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Tue, 11 Oct 2022 16:18:19 +0200 Subject: [PATCH 01/27] Replace sp-sandbox and wasmi-validation by just wasmi --- Cargo.lock | 71 ++- frame/contracts/Cargo.toml | 8 +- ..._fn.wat => event_and_return_on_deploy.wat} | 4 +- frame/contracts/fixtures/invalid_contract.wat | 4 + frame/contracts/fixtures/invalid_import.wat | 6 - frame/contracts/fixtures/invalid_module.wat | 8 + frame/contracts/proc-macro/src/lib.rs | 321 +++++------ frame/contracts/src/benchmarking/code.rs | 16 +- frame/contracts/src/benchmarking/mod.rs | 11 +- frame/contracts/src/benchmarking/sandbox.rs | 41 +- frame/contracts/src/chain_extension.rs | 30 +- frame/contracts/src/lib.rs | 13 +- frame/contracts/src/tests.rs | 32 +- frame/contracts/src/wasm/code_cache.rs | 14 +- frame/contracts/src/wasm/env_def/mod.rs | 83 --- frame/contracts/src/wasm/mod.rs | 125 ++-- frame/contracts/src/wasm/prepare.rs | 253 +++++---- frame/contracts/src/wasm/runtime.rs | 536 +++++++++++------- 18 files changed, 907 insertions(+), 669 deletions(-) rename frame/contracts/fixtures/{return_from_start_fn.wat => event_and_return_on_deploy.wat} (91%) create mode 100644 frame/contracts/fixtures/invalid_contract.wat delete mode 100644 frame/contracts/fixtures/invalid_import.wat create mode 100644 frame/contracts/fixtures/invalid_module.wat delete mode 100644 frame/contracts/src/wasm/env_def/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 6a5b562d0a791..75fa70c699ddf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3045,6 +3045,12 @@ dependencies = [ "serde", ] +[[package]] +name = "indexmap-nostd" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e04e2fd2b8188ea827b32ef11de88377086d690286ab35747ef7f9bf3ccb590" + [[package]] name = "instant" version = "0.1.12" @@ -5315,10 +5321,10 @@ dependencies = [ "sp-io", "sp-keystore", "sp-runtime", - "sp-sandbox", "sp-std", "wasm-instrument", - "wasmi-validation", + "wasmi 0.19.0", + "wasmparser-nostd", "wat", ] @@ -7339,7 +7345,7 @@ dependencies = [ "cc", "libc", "once_cell", - "spin", + "spin 0.5.2", "untrusted", "web-sys", "winapi", @@ -8029,7 +8035,7 @@ dependencies = [ "tempfile", "tracing", "tracing-subscriber", - "wasmi", + "wasmi 0.13.0", "wat", ] @@ -8046,7 +8052,7 @@ dependencies = [ "thiserror", "wasm-instrument", "wasmer", - "wasmi", + "wasmi 0.13.0", ] [[package]] @@ -8060,7 +8066,7 @@ dependencies = [ "sp-runtime-interface", "sp-sandbox", "sp-wasm-interface", - "wasmi", + "wasmi 0.13.0", ] [[package]] @@ -9579,7 +9585,7 @@ dependencies = [ "substrate-bip39", "thiserror", "tiny-bip39", - "wasmi", + "wasmi 0.13.0", "zeroize", ] @@ -9909,7 +9915,7 @@ dependencies = [ "sp-io", "sp-std", "sp-wasm-interface", - "wasmi", + "wasmi 0.13.0", "wat", ] @@ -10122,7 +10128,7 @@ dependencies = [ "log", "parity-scale-codec", "sp-std", - "wasmi", + "wasmi 0.13.0", "wasmtime", ] @@ -10147,6 +10153,12 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" +[[package]] +name = "spin" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f6002a767bff9e83f8eeecf883ecb8011875a21ae8da43bffb817a57e78cc09" + [[package]] name = "spki" version = "0.5.4" @@ -11621,7 +11633,19 @@ checksum = "fc13b3c219ca9aafeec59150d80d89851df02e0061bc357b4d66fc55a8d38787" dependencies = [ "parity-wasm 0.45.0", "wasmi-validation", - "wasmi_core", + "wasmi_core 0.2.0", +] + +[[package]] +name = "wasmi" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7428e8361e19d3affa9221ad674014b4a29381b07c755aab9b1cd4f74610221a" +dependencies = [ + "spin 0.9.4", + "wasmi_arena", + "wasmi_core 0.4.0", + "wasmparser-nostd", ] [[package]] @@ -11633,6 +11657,12 @@ dependencies = [ "parity-wasm 0.45.0", ] +[[package]] +name = "wasmi_arena" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1ea379cbb0b41f3a9f0bf7b47036d036aae7f43383d8cc487d4deccf40dee0a" + [[package]] name = "wasmi_core" version = "0.2.0" @@ -11646,6 +11676,18 @@ dependencies = [ "num-traits", ] +[[package]] +name = "wasmi_core" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c9559a70c22f27793520b9e098baea45915088fb5093dd7041fcfe238b95d4e" +dependencies = [ + "downcast-rs", + "libm", + "memory_units", + "num-traits", +] + [[package]] name = "wasmparser" version = "0.78.2" @@ -11661,6 +11703,15 @@ dependencies = [ "indexmap", ] +[[package]] +name = "wasmparser-nostd" +version = "0.91.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c37f310b5a62bfd5ae7c0f1d8e6f98af16a5d6d84ba764e9c36439ec14e318b" +dependencies = [ + "indexmap-nostd", +] + [[package]] name = "wasmtime" version = "1.0.0" diff --git a/frame/contracts/Cargo.toml b/frame/contracts/Cargo.toml index 7483ec8935890..76cb605a13af2 100644 --- a/frame/contracts/Cargo.toml +++ b/frame/contracts/Cargo.toml @@ -25,7 +25,8 @@ serde = { version = "1", optional = true, features = ["derive"] } smallvec = { version = "1", default-features = false, features = [ "const_generics", ] } -wasmi-validation = { version = "0.5", default-features = false } +wasmi = { version = "0.19", default-features = false } +wasmparser = { package = "wasmparser-nostd", version = "0.91", default-features = false } impl-trait-for-tuples = "0.2" # Only used in benchmarking to generate random contract code @@ -42,7 +43,6 @@ sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primit sp-core = { version = "6.0.0", default-features = false, path = "../../primitives/core" } sp-io = { version = "6.0.0", default-features = false, path = "../../primitives/io" } sp-runtime = { version = "6.0.0", default-features = false, path = "../../primitives/runtime" } -sp-sandbox = { version = "0.10.0-dev", default-features = false, path = "../../primitives/sandbox" } sp-std = { version = "4.0.0", default-features = false, path = "../../primitives/std" } [dev-dependencies] @@ -69,16 +69,16 @@ std = [ "sp-runtime/std", "sp-io/std", "sp-std/std", - "sp-sandbox/std", "frame-benchmarking?/std", "frame-support/std", "frame-system/std", "wasm-instrument/std", - "wasmi-validation/std", + "wasmi/std", "pallet-contracts-primitives/std", "pallet-contracts-proc-macro/full", "log/std", "rand/std", + "wasmparser/std", ] runtime-benchmarks = [ "frame-benchmarking/runtime-benchmarks", diff --git a/frame/contracts/fixtures/return_from_start_fn.wat b/frame/contracts/fixtures/event_and_return_on_deploy.wat similarity index 91% rename from frame/contracts/fixtures/return_from_start_fn.wat rename to frame/contracts/fixtures/event_and_return_on_deploy.wat index 854b552a828c2..809cfe13545a6 100644 --- a/frame/contracts/fixtures/return_from_start_fn.wat +++ b/frame/contracts/fixtures/event_and_return_on_deploy.wat @@ -3,8 +3,7 @@ (import "seal0" "seal_deposit_event" (func $seal_deposit_event (param i32 i32 i32 i32))) (import "env" "memory" (memory 1 1)) - (start $start) - (func $start + (func (export "deploy") (call $seal_deposit_event (i32.const 0) ;; The topics buffer (i32.const 0) ;; The topics buffer's length @@ -22,7 +21,6 @@ (func (export "call") (unreachable) ) - (func (export "deploy")) (data (i32.const 8) "\01\02\03\04") ) diff --git a/frame/contracts/fixtures/invalid_contract.wat b/frame/contracts/fixtures/invalid_contract.wat new file mode 100644 index 0000000000000..085569000c559 --- /dev/null +++ b/frame/contracts/fixtures/invalid_contract.wat @@ -0,0 +1,4 @@ +;; Valid module but missing the call function +(module + (func (export "deploy")) +) diff --git a/frame/contracts/fixtures/invalid_import.wat b/frame/contracts/fixtures/invalid_import.wat deleted file mode 100644 index 011f1a40e76d7..0000000000000 --- a/frame/contracts/fixtures/invalid_import.wat +++ /dev/null @@ -1,6 +0,0 @@ -;; A valid contract which does nothing at all but imports an invalid function -(module - (import "invalid" "invalid_88_99" (func (param i32 i32 i32))) - (func (export "deploy")) - (func (export "call")) -) diff --git a/frame/contracts/fixtures/invalid_module.wat b/frame/contracts/fixtures/invalid_module.wat new file mode 100644 index 0000000000000..e4a72f74273f9 --- /dev/null +++ b/frame/contracts/fixtures/invalid_module.wat @@ -0,0 +1,8 @@ +;; An invalid module +(module + (func (export "deploy")) + (func (export "call") + ;; imbalanced stack + (i32.const 7) + ) +) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index 648bf0fd1f812..be174d0299664 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -29,29 +29,27 @@ use alloc::{ string::{String, ToString}, vec::Vec, }; -use proc_macro2::TokenStream; +use proc_macro::TokenStream; +use proc_macro2::TokenStream as TokenStream2; use quote::{quote, quote_spanned, ToTokens}; -use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, Ident}; +use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, FnArg, Ident}; /// This derives `Debug` for a struct where each field must be of some numeric type. /// It interprets each field as its represents some weight and formats it as times so that /// it is readable by humans. #[proc_macro_derive(WeightDebug)] -pub fn derive_weight_debug(input: proc_macro::TokenStream) -> proc_macro::TokenStream { +pub fn derive_weight_debug(input: TokenStream) -> TokenStream { derive_debug(input, format_weight) } /// This is basically identical to the std libs Debug derive but without adding any /// bounds to existing generics. #[proc_macro_derive(ScheduleDebug)] -pub fn derive_schedule_debug(input: proc_macro::TokenStream) -> proc_macro::TokenStream { +pub fn derive_schedule_debug(input: TokenStream) -> TokenStream { derive_debug(input, format_default) } -fn derive_debug( - input: proc_macro::TokenStream, - fmt: impl Fn(&Ident) -> TokenStream, -) -> proc_macro::TokenStream { +fn derive_debug(input: TokenStream, fmt: impl Fn(&Ident) -> TokenStream2) -> TokenStream { let input = parse_macro_input!(input as DeriveInput); let name = &input.ident; let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl(); @@ -72,7 +70,7 @@ fn derive_debug( let fields = { drop(fmt); drop(data); - TokenStream::new() + TokenStream2::new() }; let tokens = quote! { @@ -91,7 +89,7 @@ fn derive_debug( /// This is only used then the `full` feature is activated. #[cfg(feature = "full")] -fn iterate_fields(data: &syn::DataStruct, fmt: impl Fn(&Ident) -> TokenStream) -> TokenStream { +fn iterate_fields(data: &syn::DataStruct, fmt: impl Fn(&Ident) -> TokenStream2) -> TokenStream2 { use syn::Fields; match &data.fields { @@ -119,7 +117,7 @@ fn iterate_fields(data: &syn::DataStruct, fmt: impl Fn(&Ident) -> TokenStream) - } } -fn format_weight(field: &Ident) -> TokenStream { +fn format_weight(field: &Ident) -> TokenStream2 { quote_spanned! { field.span() => &if self.#field > 1_000_000_000 { format!( @@ -142,7 +140,7 @@ fn format_weight(field: &Ident) -> TokenStream { } } -fn format_default(field: &Ident) -> TokenStream { +fn format_default(field: &Ident) -> TokenStream2 { quote_spanned! { field.span() => &self.#field } @@ -167,8 +165,20 @@ enum HostFnReturn { ReturnCode, } +impl HostFnReturn { + fn to_wasm_sig(&self) -> TokenStream2 { + let ok = match self { + Self::Unit => quote! { () }, + Self::U32 | Self::ReturnCode => quote! { u32 }, + }; + quote! { + Result<#ok, wasmi::core::Trap> + } + } +} + impl ToTokens for HostFn { - fn to_tokens(&self, tokens: &mut TokenStream) { + fn to_tokens(&self, tokens: &mut TokenStream2) { self.item.to_tokens(tokens); } } @@ -179,6 +189,8 @@ impl HostFn { let msg = format!("Invalid host function definition. {}", msg); syn::Error::new(span, msg) }; + + // process attributes let msg = "only #[version()] or #[unstable] attribute is allowed."; let span = item.span(); let mut attrs = item.attrs.clone(); @@ -201,16 +213,31 @@ impl HostFn { _ => Err(err(span, msg)), }?; + // process arguments: The first and second arg are treated differently (ctx, memory) + // hhey must exist and be `ctx: _` and `memory: _`. + let msg = "Every function must start with two inferred parameters: ctx: _ and memory: _"; + let special_args = item + .sig + .inputs + .iter() + .take(2) + .enumerate() + .map(|(i, arg)| is_valid_special_arg(i, arg)) + .fold(0u32, |acc, valid| if valid { acc + 1 } else { acc }); + + if special_args != 2 { + return Err(err(span, msg)) + } + + // process return type let msg = r#"Should return one of the following: - Result<(), TrapReason>, - Result, - Result"#; - let ret_ty = match item.clone().sig.output { syn::ReturnType::Type(_, ty) => Ok(ty.clone()), _ => Err(err(span, &msg)), }?; - match *ret_ty { syn::Type::Path(tp) => { let result = &tp.path.segments.last().ok_or(err(span, &msg))?; @@ -265,13 +292,13 @@ impl HostFn { }, _ => Err(err(ok_ty.span(), &msg)), }?; - let returns = match ok_ty_str.as_str() { "()" => Ok(HostFnReturn::Unit), "u32" => Ok(HostFnReturn::U32), "ReturnCode" => Ok(HostFnReturn::ReturnCode), _ => Err(err(arg1.span(), &msg)), }?; + Ok(Self { item, module, name, returns }) }, _ => Err(err(span, &msg)), @@ -280,25 +307,6 @@ impl HostFn { _ => Err(err(span, &msg)), } } - - fn to_wasm_sig(&self) -> TokenStream { - let args = self.item.sig.inputs.iter().skip(1).filter_map(|a| match a { - syn::FnArg::Typed(pt) => Some(&pt.ty), - _ => None, - }); - let returns = match &self.returns { - HostFnReturn::U32 => quote! { vec![ ::VALUE_TYPE ] }, - HostFnReturn::ReturnCode => quote! { vec![ ::VALUE_TYPE ] }, - HostFnReturn::Unit => quote! { vec![] }, - }; - - quote! { - wasm_instrument::parity_wasm::elements::FunctionType::new( - vec! [ #(<#args>::VALUE_TYPE),* ], - #returns, - ) - } - } } impl EnvDef { @@ -343,149 +351,132 @@ impl EnvDef { } } +fn is_valid_special_arg(idx: usize, arg: &FnArg) -> bool { + let pat = if let FnArg::Typed(pat) = arg { pat } else { return false }; + let ident = if let syn::Pat::Ident(ref ident) = *pat.pat { &ident.ident } else { return false }; + let name_ok = match idx { + 0 => ident == "ctx" || ident == "_ctx", + 1 => ident == "memory" || ident == "_memory", + _ => false, + }; + if !name_ok { + return false + } + matches!(*pat.ty, syn::Type::Infer(_)) +} + /// Expands environment definiton. /// Should generate source code for: /// - wasm import satisfy checks (see `expand_can_satisfy()`); /// - implementations of the host functions to be added to the wasm runtime environment (see /// `expand_impls()`). -fn expand_env(def: &mut EnvDef) -> proc_macro2::TokenStream { - let can_satisfy = expand_can_satisfy(def); +fn expand_env(def: &mut EnvDef) -> TokenStream2 { let impls = expand_impls(def); quote! { pub struct Env; - #can_satisfy #impls } } -/// Generates `can_satisfy()` method for every host function, to be used to check -/// these functions versus expected module, name and signatures when imporing them from a wasm -/// module. -fn expand_can_satisfy(def: &mut EnvDef) -> proc_macro2::TokenStream { - let checks = def.host_funcs.iter().map(|f| { - let (module, name, signature) = (&f.module, &f.name, &f.to_wasm_sig()); - quote! { - if module == #module.as_bytes() - && name == #name.as_bytes() - && signature == &#signature - { - return true; +/// Generates implementation for every host function, to register it in the contract execution +/// environment. +fn expand_impls(def: &mut EnvDef) -> TokenStream2 { + let impls = expand_functions(def, true, quote! { crate::wasm::Runtime }); + let dummy_impls = expand_functions(def, false, quote! { () }); + + quote! { + impl<'a, E> crate::wasm::Environment> for Env + where + E: Ext, + ::AccountId: + sp_core::crypto::UncheckedFrom<::Hash> + AsRef<[u8]>, + { + fn define(store: &mut wasmi::Store>, linker: &mut wasmi::Linker>) -> Result<(), wasmi::errors::LinkerError> { + #impls + Ok(()) } } - }); - let satisfy_checks = quote! { - #( #checks )* - }; - quote! { - impl crate::wasm::env_def::ImportSatisfyCheck for Env { - fn can_satisfy( - module: &[u8], - name: &[u8], - signature: &wasm_instrument::parity_wasm::elements::FunctionType, - ) -> bool { - use crate::wasm::env_def::ConvertibleToWasm; - #[cfg(not(feature = "unstable-interface"))] - if module == b"__unstable__" { - return false; - } - #satisfy_checks - return false; - } + impl crate::wasm::Environment<()> for Env + { + fn define(store: &mut wasmi::Store<()>, linker: &mut wasmi::Linker<()>) -> Result<(), wasmi::errors::LinkerError> { + #dummy_impls + Ok(()) + } } } } -/// Generates implementation for every host function, to register it in the contract execution -/// environment. -fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream { - let impls = def.host_funcs.iter().map(|f| { - let params = &f.item.sig.inputs.iter().skip(1).map(|arg| { - match arg { - syn::FnArg::Typed(pt) => { - if let syn::Pat::Ident(ident) = &*pt.pat { - let p_type = &pt.ty; - let p_name = ident.ident.clone(); - quote! { - let #p_name : <#p_type as crate::wasm::env_def::ConvertibleToWasm>::NativeType = - args.next() - .and_then(|v| <#p_type as crate::wasm::env_def::ConvertibleToWasm>::from_typed_value(v.clone())) - .expect( - "precondition: all imports should be checked against the signatures of corresponding - functions defined by `#[define_env]` proc macro by the user of the macro; - thus this can never be `None`; - qed;" - ); - } - } else { quote! { } } - }, - _ => quote! { }, +fn expand_functions( + def: &mut EnvDef, + expand_blocks: bool, + host_state: TokenStream2, +) -> 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 unstable_feat = match module.as_str() { + "__unstable__" => quote! { #[cfg(feature = "unstable-interface")] }, + _ => quote! {}, + }; + + // If we don't expand blocks (implementing for `()`) we change a few things: + // - 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__ + .host_data() + .memory() + .expect("Memory must be set when setting up host data; qed") + .data_and_store_mut(&mut __caller__); + #body + } } + } else { + quote! { || -> #wasm_output { + unreachable!() + } } + }; + let map_err = if expand_blocks { + quote! { + |reason| { + wasmi::core::Trap::host(reason) + } } - }); - - let outline = match &f.returns { - HostFnReturn::Unit => quote! { - body().map_err(|reason| { - ctx.set_trap_reason(reason); - sp_sandbox::HostError - })?; - return Ok(sp_sandbox::ReturnValue::Unit); - }, - _ => quote! { - let r = body().map_err(|reason| { - ctx.set_trap_reason(reason); - sp_sandbox::HostError - })?; - return Ok(sp_sandbox::ReturnValue::Value({ - r.to_typed_value() - })); - }, - }; - let params = params.clone(); - let (module, name, ident, body) = (&f.module, &f.name, &f.item.sig.ident, &f.item.block); - let unstable_feat = match module.as_str() { - "__unstable__" => quote! { #[cfg(feature = "unstable-interface")] }, - _ => quote! { }, - }; - quote! { - #unstable_feat - f(#module.as_bytes(), #name.as_bytes(), { - fn #ident( - ctx: &mut crate::wasm::Runtime, - args: &[sp_sandbox::Value], - ) -> Result - where - ::AccountId: sp_core::crypto::UncheckedFrom<::Hash> - + AsRef<[u8]>, - { - #[allow(unused)] - let mut args = args.iter(); - let mut body = || { - #( #params )* - #body - }; - #outline + } else { + quote! { + |reason| { reason } } - #ident:: - }); - } - }); + }; + let allow_unused = if expand_blocks { + quote! { } + } else { + quote! { #[allow(unused_variables)] } + }; - let packed_impls = quote! { - #( #impls )* - }; - quote! { - impl crate::wasm::env_def::FunctionImplProvider for Env - where - ::AccountId: - sp_core::crypto::UncheckedFrom<::Hash> + AsRef<[u8]>, - { - fn impls)>(f: &mut F) { - #packed_impls - } + quote! { + #unstable_feat + #allow_unused + linker.define(#module, #name, wasmi::Func::wrap(&mut*store, |mut __caller__: wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output { + let mut func = #inner; + func() + .map_err(#map_err) + .map(Into::into) + }))?; } + }); + quote! { + #( #impls )* } } @@ -502,7 +493,7 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream { /// ```nocompile /// #[define_env] /// pub mod some_env { -/// fn some_host_fn(ctx: Runtime, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<(), TrapReason> { +/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<(), TrapReason> { /// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) /// } /// } @@ -517,12 +508,12 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream { /// #[define_env] /// pub mod some_env { /// #[version(1)] -/// fn some_host_fn(ctx: Runtime, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { +/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { /// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) /// } /// /// #[unstable] -/// fn some_host_fn(ctx: Runtime, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { +/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { /// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) /// } /// } @@ -540,12 +531,12 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream { /// pub mod some_env { /// #[version(1)] /// #[prefixed_alias] -/// fn some_host_fn(ctx: Runtime, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { +/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { /// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) /// } /// /// #[unstable] -/// fn some_host_fn(ctx: Runtime, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { +/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result { /// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) /// } /// } @@ -562,16 +553,16 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream { /// - `Result`. /// /// The macro expands to `pub struct Env` declaration, with the following traits implementations: -/// - `pallet_contracts::wasm::env_def::ImportSatisfyCheck` -/// - `pallet_contracts::wasm::env_def::FunctionImplProvider` +/// - `pallet_contracts::wasm::Environment> where E: Ext` +/// - `pallet_contracts::wasm::Environment<()>` +/// +/// The implementation on `()` can be used in places where no `Ext` exists, yet. This is useful +/// when only checking whether a code can be instantiated without actually executing any code. #[proc_macro_attribute] -pub fn define_env( - attr: proc_macro::TokenStream, - item: proc_macro::TokenStream, -) -> proc_macro::TokenStream { +pub fn define_env(attr: TokenStream, item: TokenStream) -> TokenStream { if !attr.is_empty() { let msg = "Invalid `define_env` attribute macro: expected no attributes: `#[define_env]`."; - let span = proc_macro2::TokenStream::from(attr).span(); + let span = TokenStream2::from(attr).span(); return syn::Error::new(span, msg).to_compile_error().into() } diff --git a/frame/contracts/src/benchmarking/code.rs b/frame/contracts/src/benchmarking/code.rs index b14b107f34c90..c1e9f3208b286 100644 --- a/frame/contracts/src/benchmarking/code.rs +++ b/frame/contracts/src/benchmarking/code.rs @@ -28,10 +28,6 @@ use crate::{Config, Determinism}; use frame_support::traits::Get; use sp_core::crypto::UncheckedFrom; use sp_runtime::traits::Hash; -use sp_sandbox::{ - default_executor::{EnvironmentDefinitionBuilder, Memory}, - SandboxEnvironmentBuilder, SandboxMemory, -}; use sp_std::{borrow::ToOwned, prelude::*}; use wasm_instrument::parity_wasm::{ builder, @@ -128,7 +124,7 @@ pub struct ImportedFunction { pub struct WasmModule { pub code: Vec, pub hash: ::Output, - memory: Option, + pub memory: Option, } impl From for WasmModule @@ -395,16 +391,6 @@ where .into() } - /// Creates a memory instance for use in a sandbox with dimensions declared in this module - /// and adds it to `env`. A reference to that memory is returned so that it can be used to - /// access the memory contents from the supervisor. - pub fn add_memory(&self, env: &mut EnvironmentDefinitionBuilder) -> Option { - let memory = if let Some(memory) = &self.memory { memory } else { return None }; - let memory = Memory::new(memory.min_pages, Some(memory.max_pages)).unwrap(); - env.add_memory("env", "memory", memory.clone()); - Some(memory) - } - pub fn unary_instr(instr: Instruction, repeat: u32) -> Self { use body::DynInstr::{RandomI64Repeated, Regular}; ModuleDefinition { diff --git a/frame/contracts/src/benchmarking/mod.rs b/frame/contracts/src/benchmarking/mod.rs index a952eeb2cbd3a..47cd571f014d2 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -425,7 +425,7 @@ benchmarks! { .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().map(|a| a.encode()).flatten().collect::>(); + let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::>(); let code = WasmModule::::from(ModuleDefinition { memory: Some(ImportedMemory::max::()), imported_functions: vec![ImportedFunction { @@ -462,7 +462,7 @@ benchmarks! { .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().map(|a| a.encode()).flatten().collect::>(); + let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::>(); let accounts_len = accounts_bytes.len(); let pages = code::max_pages::(); let code = WasmModule::::from(ModuleDefinition { @@ -2014,10 +2014,9 @@ benchmarks! { let r in 0 .. 1; let key_type = sp_core::crypto::KeyTypeId(*b"code"); let pub_keys_bytes = (0..r * API_BENCHMARK_BATCH_SIZE) - .map(|_| { + .flat_map(|_| { sp_io::crypto::ecdsa_generate(key_type, None).0 }) - .flatten() .collect::>(); let pub_keys_bytes_len = pub_keys_bytes.len() as i32; let code = WasmModule::::from(ModuleDefinition { @@ -2868,7 +2867,7 @@ benchmarks! { #[extra] ink_erc20_transfer { let g in 0 .. 1; - let gas_metering = if g == 0 { false } else { true }; + let gas_metering = g != 0; let code = load_benchmark!("ink_erc20"); let data = { let new: ([u8; 4], BalanceOf) = ([0x9b, 0xae, 0x9d, 0x5e], 1000u32.into()); @@ -2906,7 +2905,7 @@ benchmarks! { #[extra] solang_erc20_transfer { let g in 0 .. 1; - let gas_metering = if g == 0 { false } else { true }; + let gas_metering = g != 0; let code = include_bytes!("../../benchmarks/solang_erc20.wasm"); let caller = account::("instantiator", 0, 0); let mut balance = [0u8; 32]; diff --git a/frame/contracts/src/benchmarking/sandbox.rs b/frame/contracts/src/benchmarking/sandbox.rs index 451d2fe433913..b0cb9297d5656 100644 --- a/frame/contracts/src/benchmarking/sandbox.rs +++ b/frame/contracts/src/benchmarking/sandbox.rs @@ -19,22 +19,20 @@ /// ! sandbox to execute the wasm code. This is because we do not need the full /// ! environment that provides the seal interface as imported functions. use super::{code::WasmModule, Config}; +use crate::wasm::{Environment, PrefabWasmModule}; use sp_core::crypto::UncheckedFrom; -use sp_sandbox::{ - default_executor::{EnvironmentDefinitionBuilder, Instance, Memory}, - SandboxEnvironmentBuilder, SandboxInstance, -}; +use wasmi::{errors::LinkerError, Func, Linker, StackLimits, Store}; -/// Minimal execution environment without any exported functions. +/// Minimal execution environment without any imported functions. pub struct Sandbox { - instance: Instance<()>, - _memory: Option, + entry_point: Func, + store: Store<()>, } impl Sandbox { /// Invoke the `call` function of a contract code and panic on any execution error. pub fn invoke(&mut self) { - self.instance.invoke("call", &[], &mut ()).unwrap(); + self.entry_point.call(&mut self.store, &[], &mut []).unwrap(); } } @@ -46,10 +44,27 @@ where /// Creates an instance from the supplied module and supplies as much memory /// to the instance as the module declares as imported. fn from(module: &WasmModule) -> Self { - let mut env_builder = EnvironmentDefinitionBuilder::new(); - let memory = module.add_memory(&mut env_builder); - let instance = Instance::new(&module.code, &env_builder, &mut ()) - .expect("Failed to create benchmarking Sandbox instance"); - Self { instance, _memory: memory } + let memory = module + .memory + .as_ref() + .map(|mem| (mem.min_pages, mem.max_pages)) + .unwrap_or((0, 0)); + let (store, _memory, instance) = PrefabWasmModule::::instantiate::( + &module.code, + (), + memory, + StackLimits::default(), + ) + .expect("Failed to create benchmarking Sandbox instance"); + let entry_point = instance.get_export(&store, "call").unwrap().into_func().unwrap(); + Self { entry_point, store } + } +} + +struct EmptyEnv; + +impl Environment<()> for EmptyEnv { + fn define(_store: &mut Store<()>, _linker: &mut Linker<()>) -> Result<(), LinkerError> { + Ok(()) } } diff --git a/frame/contracts/src/chain_extension.rs b/frame/contracts/src/chain_extension.rs index d0e0cf5cf95cb..3c3e9b1ef0f59 100644 --- a/frame/contracts/src/chain_extension.rs +++ b/frame/contracts/src/chain_extension.rs @@ -270,6 +270,7 @@ impl<'a, 'b, E: Ext> Environment<'a, 'b, E, InitState> { /// ever create this type. Chain extensions merely consume it. pub(crate) fn new( runtime: &'a mut Runtime<'b, E>, + memory: &'a mut [u8], id: u32, input_ptr: u32, input_len: u32, @@ -277,7 +278,7 @@ impl<'a, 'b, E: Ext> Environment<'a, 'b, E, InitState> { output_len_ptr: u32, ) -> Self { Environment { - inner: Inner { runtime, id, input_ptr, input_len, output_ptr, output_len_ptr }, + inner: Inner { runtime, memory, id, input_ptr, input_len, output_ptr, output_len_ptr }, phantom: PhantomData, } } @@ -338,9 +339,11 @@ where /// charge the overall costs either using `max_len` (worst case approximation) or using /// [`in_len()`](Self::in_len). pub fn read(&self, max_len: u32) -> Result> { - self.inner - .runtime - .read_sandbox_memory(self.inner.input_ptr, self.inner.input_len.min(max_len)) + self.inner.runtime.read_sandbox_memory( + self.inner.memory, + self.inner.input_ptr, + self.inner.input_len.min(max_len), + ) } /// Reads `min(buffer.len(), in_len) from contract memory. @@ -354,7 +357,11 @@ where let buffer = core::mem::take(buffer); &mut buffer[..len.min(self.inner.input_len as usize)] }; - self.inner.runtime.read_sandbox_memory_into_buf(self.inner.input_ptr, sliced)?; + self.inner.runtime.read_sandbox_memory_into_buf( + self.inner.memory, + self.inner.input_ptr, + sliced, + )?; *buffer = sliced; Ok(()) } @@ -366,14 +373,20 @@ where /// weight of the chain extension. This should usually be the case when fixed input types /// are used. pub fn read_as(&mut self) -> Result { - self.inner.runtime.read_sandbox_memory_as(self.inner.input_ptr) + self.inner + .runtime + .read_sandbox_memory_as(self.inner.memory, self.inner.input_ptr) } /// Reads and decodes a type with a dynamic size from contract memory. /// /// Make sure to include `len` in your weight calculations. pub fn read_as_unbounded(&mut self, len: u32) -> Result { - self.inner.runtime.read_sandbox_memory_as_unbounded(self.inner.input_ptr, len) + self.inner.runtime.read_sandbox_memory_as_unbounded( + self.inner.memory, + self.inner.input_ptr, + len, + ) } /// The length of the input as passed in as `input_len`. @@ -406,6 +419,7 @@ where weight_per_byte: Option, ) -> Result<()> { self.inner.runtime.write_sandbox_output( + self.inner.memory, self.inner.output_ptr, self.inner.output_len_ptr, buffer, @@ -426,6 +440,8 @@ where struct Inner<'a, 'b, E: Ext> { /// The runtime contains all necessary functions to interact with the running contract. runtime: &'a mut Runtime<'b, E>, + /// Reference to the contracts memory. + memory: &'a mut [u8], /// Verbatim argument passed to `seal_call_chain_extension`. id: u32, /// Verbatim argument passed to `seal_call_chain_extension`. diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs index b2eb0439d6ced..9932eaf4e68d4 100644 --- a/frame/contracts/src/lib.rs +++ b/frame/contracts/src/lib.rs @@ -102,7 +102,7 @@ use crate::{ exec::{AccountIdOf, ExecError, Executable, Stack as ExecStack}, gas::GasMeter, storage::{meter::Meter as StorageMeter, ContractInfo, DeletedContract, Storage}, - wasm::{OwnerInfo, PrefabWasmModule}, + wasm::{OwnerInfo, PrefabWasmModule, TryInstantiate}, weights::WeightInfo, }; use codec::{Codec, Encode, HasCompact}; @@ -1009,8 +1009,14 @@ where determinism: Determinism, ) -> CodeUploadResult, BalanceOf> { let schedule = T::Schedule::get(); - let module = PrefabWasmModule::from_code(code, &schedule, origin, determinism) - .map_err(|(err, _)| err)?; + let module = PrefabWasmModule::from_code( + code, + &schedule, + origin, + determinism, + TryInstantiate::Instantiate, + ) + .map_err(|(err, _)| err)?; let deposit = module.open_deposit(); if let Some(storage_deposit_limit) = storage_deposit_limit { ensure!(storage_deposit_limit >= deposit, >::StorageDepositLimitExhausted); @@ -1135,6 +1141,7 @@ where &schedule, origin.clone(), Determinism::Deterministic, + TryInstantiate::Skip, ) .map_err(|(err, msg)| { debug_message.as_mut().map(|buffer| buffer.extend(msg.as_bytes())); diff --git a/frame/contracts/src/tests.rs b/frame/contracts/src/tests.rs index bc2ee31681d7f..244feede060bb 100644 --- a/frame/contracts/src/tests.rs +++ b/frame/contracts/src/tests.rs @@ -514,7 +514,7 @@ fn calling_plain_account_fails() { #[test] fn instantiate_and_call_and_deposit_event() { - let (wasm, code_hash) = compile_module::("return_from_start_fn").unwrap(); + let (wasm, code_hash) = compile_module::("event_and_return_on_deploy").unwrap(); ExtBuilder::default().existential_deposit(500).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); @@ -3720,10 +3720,36 @@ fn contract_reverted() { #[test] fn code_rejected_error_works() { - let (wasm, _) = compile_module::("invalid_import").unwrap(); ExtBuilder::default().existential_deposit(200).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); + let (wasm, _) = compile_module::("invalid_module").unwrap(); + assert_noop!( + Contracts::upload_code( + RuntimeOrigin::signed(ALICE), + wasm.clone(), + None, + Determinism::Deterministic + ), + >::CodeRejected, + ); + let result = Contracts::bare_instantiate( + ALICE, + 0, + GAS_LIMIT, + None, + Code::Upload(wasm), + vec![], + vec![], + true, + ); + assert_err!(result.result, >::CodeRejected); + assert_eq!( + std::str::from_utf8(&result.debug_message).unwrap(), + "validation of new code failed" + ); + + let (wasm, _) = compile_module::("invalid_contract").unwrap(); assert_noop!( Contracts::upload_code( RuntimeOrigin::signed(ALICE), @@ -3747,7 +3773,7 @@ fn code_rejected_error_works() { assert_err!(result.result, >::CodeRejected); assert_eq!( std::str::from_utf8(&result.debug_message).unwrap(), - "module imports a non-existent function" + "call function isn't exported" ); }); } diff --git a/frame/contracts/src/wasm/code_cache.rs b/frame/contracts/src/wasm/code_cache.rs index 3ede6db6db5a1..eb337ac682860 100644 --- a/frame/contracts/src/wasm/code_cache.rs +++ b/frame/contracts/src/wasm/code_cache.rs @@ -192,7 +192,10 @@ where pub fn reinstrument( prefab_module: &mut PrefabWasmModule, schedule: &Schedule, -) -> Result { +) -> Result +where + T::AccountId: UncheckedFrom + AsRef<[u8]>, +{ let original_code = >::get(&prefab_module.code_hash).ok_or(Error::::CodeNotFound)?; let original_code_len = original_code.len(); @@ -201,9 +204,12 @@ pub fn reinstrument( // as the contract is already deployed and every change in size would be the result // of changes in the instrumentation algorithm controlled by the chain authors. prefab_module.code = WeakBoundedVec::force_from( - prepare::reinstrument_contract::(&original_code, schedule, prefab_module.determinism) - .map_err(|_| >::CodeRejected)?, - Some("Contract exceeds limit after re-instrumentation."), + prepare::reinstrument::( + &original_code, + schedule, + prefab_module.determinism, + )?, + Some("Contract exceeds size limit after re-instrumentation."), ); prefab_module.instruction_weights_version = schedule.instruction_weights.version; >::insert(&prefab_module.code_hash, &*prefab_module); diff --git a/frame/contracts/src/wasm/env_def/mod.rs b/frame/contracts/src/wasm/env_def/mod.rs deleted file mode 100644 index be6e688c97868..0000000000000 --- a/frame/contracts/src/wasm/env_def/mod.rs +++ /dev/null @@ -1,83 +0,0 @@ -// This file is part of Substrate. - -// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 - -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -use super::Runtime; -use crate::exec::Ext; - -use sp_sandbox::Value; -use wasm_instrument::parity_wasm::elements::{FunctionType, ValueType}; - -pub trait ConvertibleToWasm: Sized { - const VALUE_TYPE: ValueType; - type NativeType; - fn to_typed_value(self) -> Value; - fn from_typed_value(_: Value) -> Option; -} -impl ConvertibleToWasm for i32 { - const VALUE_TYPE: ValueType = ValueType::I32; - type NativeType = i32; - fn to_typed_value(self) -> Value { - Value::I32(self) - } - fn from_typed_value(v: Value) -> Option { - v.as_i32() - } -} -impl ConvertibleToWasm for u32 { - const VALUE_TYPE: ValueType = ValueType::I32; - type NativeType = u32; - fn to_typed_value(self) -> Value { - Value::I32(self as i32) - } - fn from_typed_value(v: Value) -> Option { - match v { - Value::I32(v) => Some(v as u32), - _ => None, - } - } -} -impl ConvertibleToWasm for u64 { - const VALUE_TYPE: ValueType = ValueType::I64; - type NativeType = u64; - fn to_typed_value(self) -> Value { - Value::I64(self as i64) - } - fn from_typed_value(v: Value) -> Option { - match v { - Value::I64(v) => Some(v as u64), - _ => None, - } - } -} - -pub type HostFunc = fn( - &mut Runtime, - &[sp_sandbox::Value], -) -> Result; - -pub trait FunctionImplProvider { - fn impls)>(f: &mut F); -} - -/// This trait can be used to check whether the host environment can satisfy -/// a requested function import. -pub trait ImportSatisfyCheck { - /// Returns `true` if the host environment contains a function with - /// the specified name and its type matches to the given type, or `false` - /// otherwise. - fn can_satisfy(module: &[u8], name: &[u8], func_type: &FunctionType) -> bool; -} diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 053729730e679..a9bcd54ee955e 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -18,19 +18,19 @@ //! This module provides a means for executing contracts //! represented in wasm. -#[macro_use] -mod env_def; mod code_cache; mod prepare; mod runtime; #[cfg(feature = "runtime-benchmarks")] pub use crate::wasm::code_cache::reinstrument; -pub use crate::wasm::runtime::{CallFlags, ReturnCode, Runtime, RuntimeCosts}; +pub use crate::wasm::{ + prepare::TryInstantiate, + runtime::{CallFlags, Environment, ReturnCode, Runtime, RuntimeCosts}, +}; use crate::{ exec::{ExecResult, Executable, ExportedFunction, Ext}, gas::GasMeter, - wasm::env_def::FunctionImplProvider, AccountIdOf, BalanceOf, CodeHash, CodeStorage, CodeVec, Config, Error, RelaxedCodeVec, Schedule, }; @@ -38,10 +38,12 @@ use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::dispatch::{DispatchError, DispatchResult}; use sp_core::crypto::UncheckedFrom; use sp_runtime::RuntimeDebug; -use sp_sandbox::{SandboxEnvironmentBuilder, SandboxInstance, SandboxMemory}; use sp_std::prelude::*; #[cfg(test)] pub use tests::MockExt; +use wasmi::{ + Config as WasmiConfig, Engine, Instance, Linker, Memory, MemoryType, Module, StackLimits, Store, +}; /// A prepared wasm module ready for execution. /// @@ -151,12 +153,14 @@ where schedule: &Schedule, owner: AccountIdOf, determinism: Determinism, + try_instantiate: TryInstantiate, ) -> Result { - let module = prepare::prepare_contract( + let module = prepare::prepare::( original_code.try_into().map_err(|_| (>::CodeTooLarge.into(), ""))?, schedule, owner, determinism, + try_instantiate, )?; Ok(module) } @@ -189,6 +193,39 @@ where } } + pub fn instantiate( + code: &[u8], + host_state: H, + memory: (u32, u32), + stack_limits: StackLimits, + ) -> Result<(Store, Memory, Instance), wasmi::Error> + where + E: Environment, + { + let mut config = WasmiConfig::default(); + config + .set_stack_limits(stack_limits) + .wasm_multi_value(false) + .wasm_mutable_global(false) + .wasm_sign_extension(false) + .wasm_saturating_float_to_int(false); + let engine = Engine::new(&config); + let module = Module::new(&engine, code).unwrap(); + let mut store = Store::new(&engine, host_state); + let mut linker = Linker::new(); + E::define(&mut store, &mut linker)?; + let memory = Memory::new(&mut store, MemoryType::new(memory.0, Some(memory.1))).expect( + "Memory bounds are defined as `u32`. Hence the cannot be larger than u32::MAX; qed", + ); + linker + .define("env", "memory", memory) + .expect("We just created the linker. It has no define with this name attached; qed"); + + let instance = linker.instantiate(&mut store, &module)?.ensure_no_start(&mut store)?; + + Ok((store, memory, instance)) + } + /// Create and store the module without checking nor instrumenting the passed code. /// /// # Note @@ -201,7 +238,7 @@ where schedule: &Schedule, owner: T::AccountId, ) -> DispatchResult { - let executable = prepare::benchmarking::prepare_contract(original_code, schedule, owner) + let executable = prepare::benchmarking::prepare(original_code, schedule, owner) .map_err::(Into::into)?; code_cache::store(executable, false) } @@ -247,36 +284,35 @@ where function: &ExportedFunction, input_data: Vec, ) -> ExecResult { - let memory = sp_sandbox::default_executor::Memory::new(self.initial, Some(self.maximum)) - .unwrap_or_else(|_| { - // unlike `.expect`, explicit panic preserves the source location. - // Needed as we can't use `RUST_BACKTRACE` in here. - panic!( - "exec.prefab_module.initial can't be greater than exec.prefab_module.maximum; - thus Memory::new must not fail; - qed" - ) - }); - - let mut imports = sp_sandbox::default_executor::EnvironmentDefinitionBuilder::new(); - imports.add_memory(self::prepare::IMPORT_MODULE_MEMORY, "memory", memory.clone()); - runtime::Env::impls(&mut |module, name, func_ptr| { - imports.add_host_func(module, name, func_ptr); - }); + let runtime = Runtime::new(ext, input_data); + let (mut store, memory, instance) = Self::instantiate::( + self.code.as_slice(), + runtime, + (self.initial, self.maximum), + StackLimits::default(), + ) + .map_err(|msg| { + log::debug!(target: "runtime::contracts", "failed to instantiate code: {}", msg); + Error::::CodeRejected + })?; + store.state_mut().set_memory(memory); + + let exported_func = instance + .get_export(&store, function.identifier()) + .and_then(|export| export.into_func()) + .ok_or_else(|| { + log::error!(target: "runtime::contracts", "failed to find entry point"); + Error::::CodeRejected + })?; // We store before executing so that the code hash is available in the constructor. - let code = self.code.clone(); if let &ExportedFunction::Constructor = function { code_cache::store(self, true)?; } - // Instantiate the instance from the instrumented module code and invoke the contract - // entrypoint. - let mut runtime = Runtime::new(ext, input_data, memory); - let result = sp_sandbox::default_executor::Instance::new(&code, &imports, &mut runtime) - .and_then(|mut instance| instance.invoke(function.identifier(), &[], &mut runtime)); + let result = exported_func.call(&mut store, &[], &mut []); - runtime.to_execution_result(result) + store.into_state().to_execution_result(result) } fn code_hash(&self) -> &CodeHash { @@ -307,7 +343,7 @@ mod tests { }; use assert_matches::assert_matches; use frame_support::{ - assert_ok, + assert_err, assert_ok, dispatch::DispatchResultWithPostInfo, weights::{OldWeight, Weight}, }; @@ -588,8 +624,9 @@ mod tests { &schedule, ALICE, Determinism::Deterministic, + TryInstantiate::Skip, ) - .unwrap(); + .map_err(|err| err.0)?; executable.execute(ext.borrow_mut(), &ExportedFunction::Call, input_data) } @@ -782,10 +819,7 @@ mod tests { "#; let mut mock_ext = MockExt::default(); let input = vec![0xff, 0x2a, 0x99, 0x88]; - frame_support::assert_err!( - execute(CODE, input.clone(), &mut mock_ext), - >::InputForwarded, - ); + assert_err!(execute(CODE, input.clone(), &mut mock_ext), >::InputForwarded,); assert_eq!( &mock_ext.calls, @@ -1639,35 +1673,32 @@ mod tests { assert_ok!(execute(CODE_VALUE_TRANSFERRED, vec![], MockExt::default())); } - const CODE_RETURN_FROM_START_FN: &str = r#" + const START_FN_ILLEGAL: &str = r#" (module (import "seal0" "seal_return" (func $seal_return (param i32 i32 i32))) (import "env" "memory" (memory 1 1)) (start $start) (func $start - (call $seal_return - (i32.const 0) - (i32.const 8) - (i32.const 4) - ) (unreachable) ) (func (export "call") (unreachable) ) - (func (export "deploy")) + + (func (export "deploy") + (unreachable) + ) (data (i32.const 8) "\01\02\03\04") ) "#; #[test] - fn return_from_start_fn() { - let output = execute(CODE_RETURN_FROM_START_FN, vec![], MockExt::default()).unwrap(); - - assert_eq!(output, ExecReturnValue { flags: ReturnFlags::empty(), data: vec![1, 2, 3, 4] }); + fn start_fn_illegal() { + let output = execute(START_FN_ILLEGAL, vec![], MockExt::default()); + assert_err!(output, >::CodeRejected,); } const CODE_TIMESTAMP_NOW: &str = r#" diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 3e6b9eee96680..7b84397f31a2d 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -22,20 +22,38 @@ use crate::{ chain_extension::ChainExtension, storage::meter::Diff, - wasm::{env_def::ImportSatisfyCheck, Determinism, OwnerInfo, PrefabWasmModule}, + wasm::{Determinism, Environment, OwnerInfo, PrefabWasmModule}, AccountIdOf, CodeVec, Config, Error, Schedule, }; use codec::{Encode, MaxEncodedLen}; +use sp_core::crypto::UncheckedFrom; use sp_runtime::{traits::Hash, DispatchError}; use sp_std::prelude::*; use wasm_instrument::parity_wasm::elements::{ self, External, Internal, MemoryType, Type, ValueType, }; +use wasmi::StackLimits; +use wasmparser::{Validator, WasmFeatures}; /// Imported memory must be located inside this module. The reason for hardcoding is that current /// compiler toolchains might not support specifying other modules than "env" for memory imports. pub const IMPORT_MODULE_MEMORY: &str = "env"; +/// Determines whether a module should be instantiated during preparation. +pub enum TryInstantiate { + /// Do the instantation to make sure that the module is valid. + /// + /// This should be used if a module is only uploaded but not executed. We need + /// to make sure that it can be actually instantiated. + Instantiate, + /// Skip the instantation during preparation. + /// + /// This makes sense when the preparation takes place as part of an instantation. Then + /// this instantiation would fail the whole transaction and an extra check is not + /// necessary. + Skip, +} + struct ContractModule<'a, T: Config> { /// A deserialized module. The module is valid (this is Guaranteed by `new` method). module: elements::Module, @@ -48,14 +66,9 @@ impl<'a, T: Config> ContractModule<'a, T> { /// Returns `Err` if the `original_code` couldn't be decoded or /// if it contains an invalid module. fn new(original_code: &[u8], schedule: &'a Schedule) -> Result { - use wasmi_validation::{validate_module, PlainValidator}; - let module = elements::deserialize_buffer(original_code).map_err(|_| "Can't decode wasm code")?; - // Make sure that the module is valid. - validate_module::(&module, ()).map_err(|_| "Module is not valid")?; - // Return a `ContractModule` instance with // __valid__ module. Ok(ContractModule { module, schedule }) @@ -284,22 +297,29 @@ impl<'a, T: Config> ContractModule<'a, T> { /// - checks any imported function against defined host functions set, incl. their signatures. /// - if there is a memory import, returns it's descriptor /// `import_fn_banlist`: list of function names that are disallowed to be imported - fn scan_imports( + fn scan_imports( &self, import_fn_banlist: &[&[u8]], ) -> Result, &'static str> { let module = &self.module; - - let types = module.type_section().map(|ts| ts.types()).unwrap_or(&[]); let import_entries = module.import_section().map(|is| is.entries()).unwrap_or(&[]); - let mut imported_mem_type = None; for import in import_entries { - let type_idx = match *import.external() { + match *import.external() { External::Table(_) => return Err("Cannot import tables"), External::Global(_) => return Err("Cannot import globals"), - External::Function(ref type_idx) => type_idx, + External::Function(_) => { + if !T::ChainExtension::enabled() && + import.field().as_bytes() == b"seal_call_chain_extension" + { + return Err("module uses chain extensions but chain extensions are disabled") + } + + if import_fn_banlist.iter().any(|f| import.field().as_bytes() == *f) { + return Err("module imports a banned function") + } + }, External::Memory(ref memory_type) => { if import.module() != IMPORT_MODULE_MEMORY { return Err("Invalid module for imported memory") @@ -313,22 +333,6 @@ impl<'a, T: Config> ContractModule<'a, T> { imported_mem_type = Some(memory_type); continue }, - }; - - let Type::Function(ref func_ty) = types - .get(*type_idx as usize) - .ok_or("validation: import entry points to a non-existent type")?; - - if !T::ChainExtension::enabled() && - import.field().as_bytes() == b"seal_call_chain_extension" - { - return Err("module uses chain extensions but chain extensions are disabled") - } - - if import_fn_banlist.iter().any(|f| import.field().as_bytes() == *f) || - !C::can_satisfy(import.module().as_bytes(), import.field().as_bytes(), func_ty) - { - return Err("module imports a non-existent function") } } Ok(imported_mem_type) @@ -366,13 +370,62 @@ fn get_memory_limits( } } -fn check_and_instrument( - original_code: &[u8], +/// Loads the given module given in `original_code`, performs some checks on it and +/// does some preprocessing. +/// +/// The checks are: +/// +/// - provided code is a valid wasm module. +/// - the module doesn't define an internal memory instance, +/// - imported memory (if any) doesn't reserve more memory than permitted by the `schedule`, +/// - all imported functions from the external environment matches defined by `env` module, +/// +/// The preprocessing includes injecting code for gas metering and metering the height of stack. +pub fn prepare( + original_code: CodeVec, schedule: &Schedule, + owner: AccountIdOf, determinism: Determinism, -) -> Result<(Vec, (u32, u32)), &'static str> { - let result = (|| { - let contract_module = ContractModule::new(original_code, schedule)?; + try_instantiate: TryInstantiate, +) -> Result, (DispatchError, &'static str)> +where + E: Environment<()>, + T::AccountId: UncheckedFrom + AsRef<[u8]>, +{ + // Do not enable any features here. Any additional feature needs to be carefully + // checked for potential security issues. For example, enabling multi value could lead + // to a DoS vector: It breaks our assumption that branch instructions are of constant time. + // Depending on the implementation they can linearly depend on the amount of values returned + // from a block. + Validator::new_with_features(WasmFeatures { + relaxed_simd: false, + threads: false, + tail_call: false, + multi_memory: false, + exceptions: false, + memory64: false, + extended_const: false, + component_model: false, + // This is not our only defense: We check for float types later in the preparation + // process. Additionally, all instructions explictily need to have weights assigned + // or the deployment will fail. We have none assigned for float instructions. + deterministic_only: matches!(determinism, Determinism::AllowIndeterminism), + mutable_global: false, + saturating_float_to_int: false, + sign_extension: false, + bulk_memory: false, + multi_value: false, + reference_types: false, + simd: false, + }) + .validate_all(original_code.as_ref()) + .map_err(|err| { + log::debug!(target: "runtime::contracts", "{}", err); + (Error::::CodeRejected.into(), "validation of new code failed") + })?; + + let (code, (initial, maximum)) = (|| { + let contract_module = ContractModule::new(original_code.as_ref(), schedule)?; contract_module.scan_exports()?; contract_module.ensure_no_internal_memory()?; contract_module.ensure_table_size_limit(schedule.limits.table_size)?; @@ -387,7 +440,7 @@ fn check_and_instrument( // We disallow importing `gas` function here since it is treated as implementation detail. let disallowed_imports = [b"gas".as_ref()]; let memory_limits = - get_memory_limits(contract_module.scan_imports::(&disallowed_imports)?, schedule)?; + get_memory_limits(contract_module.scan_imports(&disallowed_imports)?, schedule)?; let code = contract_module .inject_gas_metering(determinism)? @@ -395,24 +448,32 @@ fn check_and_instrument( .into_wasm_code()?; Ok((code, memory_limits)) - })(); - - if let Err(msg) = &result { - log::debug!(target: "runtime::contracts", "CodeRejected: {}", msg); + })() + .map_err(|msg: &str| { + log::debug!(target: "runtime::contracts", "new code rejected: {}", msg); + (Error::::CodeRejected.into(), msg) + })?; + + // This will make sure that the module can be actually run within wasmi: + // + // - Doesn't use any unknown imports. + // - Doesn't explode the wasmi bytecode generation. + if matches!(try_instantiate, TryInstantiate::Instantiate) { + // We don't actually ever run any code so we can get away with a minimal stack which + // reduces the amount of memory that needs to be zeroed. + let stack_limits = StackLimits::new(1, 1, 0).expect("initial <= max; qed"); + PrefabWasmModule::::instantiate::( + original_code.as_ref(), + (), + (initial, maximum), + stack_limits, + ) + .map_err(|err| { + log::debug!(target: "runtime::contracts", "{}", err); + (Error::::CodeRejected.into(), "new code rejected after instrumentation") + })?; } - result -} - -fn do_preparation( - original_code: CodeVec, - schedule: &Schedule, - owner: AccountIdOf, - determinism: Determinism, -) -> Result, (DispatchError, &'static str)> { - let (code, (initial, maximum)) = - check_and_instrument::(original_code.as_ref(), schedule, determinism) - .map_err(|msg| (>::CodeRejected.into(), msg))?; let original_code_len = original_code.len(); let mut module = PrefabWasmModule { @@ -420,10 +481,10 @@ fn do_preparation( initial, maximum, code: code.try_into().map_err(|_| (>::CodeTooLarge.into(), ""))?, - determinism, code_hash: T::Hashing::hash(&original_code), original_code: Some(original_code), owner_info: None, + determinism, }; // We need to add the sizes of the `#[codec(skip)]` fields which are stored in different @@ -441,37 +502,30 @@ fn do_preparation( Ok(module) } -/// Loads the given module given in `original_code`, performs some checks on it and -/// does some preprocessing. -/// -/// The checks are: -/// -/// - provided code is a valid wasm module. -/// - the module doesn't define an internal memory instance, -/// - imported memory (if any) doesn't reserve more memory than permitted by the `schedule`, -/// - all imported functions from the external environment matches defined by `env` module, -/// -/// The preprocessing includes injecting code for gas metering and metering the height of stack. -pub fn prepare_contract( - original_code: CodeVec, - schedule: &Schedule, - owner: AccountIdOf, - determinism: Determinism, -) -> Result, (DispatchError, &'static str)> { - do_preparation::(original_code, schedule, owner, determinism) -} - -/// The same as [`prepare_contract`] but without constructing a new [`PrefabWasmModule`] +/// Just run the instrumentation without checking the code. /// -/// # Note -/// -/// Use this when an existing contract should be re-instrumented with a newer schedule version. -pub fn reinstrument_contract( +/// Only run this on already uploaded code which is already validated. This also doesn't +/// check new newly instrumented code as there is nothing we can do on a failure here +/// anyways: The code is already deployed and it doesn't matter if it fails here or when +/// actually running the code. +pub fn reinstrument( original_code: &[u8], schedule: &Schedule, determinism: Determinism, -) -> Result, &'static str> { - Ok(check_and_instrument::(original_code, schedule, determinism)?.0) +) -> Result, &'static str> +where + E: Environment<()>, + T::AccountId: UncheckedFrom + AsRef<[u8]>, +{ + let contract_module = ContractModule::new(original_code, schedule)?; + contract_module + .inject_gas_metering(determinism) + .and_then(|module| module.inject_stack_height_metering()) + .and_then(|module| module.into_wasm_code()) + .map_err(|msg| { + log::error!(target: "runtime::contracts", "CodeRejected during reinstrument: {}", msg); + Error::::CodeRejected.into() + }) } /// Alternate (possibly unsafe) preparation functions used only for benchmarking. @@ -482,29 +536,22 @@ pub fn reinstrument_contract( /// in production code. #[cfg(feature = "runtime-benchmarks")] pub mod benchmarking { - use super::{elements::FunctionType, *}; - - impl ImportSatisfyCheck for () { - fn can_satisfy(_module: &[u8], _name: &[u8], _func_type: &FunctionType) -> bool { - true - } - } + use super::*; /// Prepare function that neither checks nor instruments the passed in code. - pub fn prepare_contract( + pub fn prepare( original_code: Vec, schedule: &Schedule, owner: AccountIdOf, ) -> Result, &'static str> { let contract_module = ContractModule::new(&original_code, schedule)?; - let memory_limits = get_memory_limits(contract_module.scan_imports::<()>(&[])?, schedule)?; + let memory_limits = get_memory_limits(contract_module.scan_imports(&[])?, schedule)?; Ok(PrefabWasmModule { instruction_weights_version: schedule.instruction_weights.version, initial: memory_limits.0, maximum: memory_limits.1, code_hash: T::Hashing::hash(&original_code), original_code: Some(original_code.try_into().map_err(|_| "Original code too large")?), - determinism: Determinism::Deterministic, code: contract_module .into_wasm_code()? .try_into() @@ -515,6 +562,7 @@ pub mod benchmarking { deposit: Default::default(), refcount: 0, }), + determinism: Determinism::Deterministic, }) } } @@ -540,27 +588,28 @@ mod tests { #[allow(unreachable_code)] mod env { use super::*; + use crate::wasm::runtime::TrapReason; // Define test environment for tests. We need ImportSatisfyCheck // implementation from it. So actual implementations doesn't matter. #[define_env] pub mod test_env { - fn panic(_ctx: crate::wasm::Runtime) -> Result<(), TrapReason> { + fn panic(_ctx: _, _memory: _) -> Result<(), TrapReason> { Ok(()) } // gas is an implementation defined function and a contract can't import it. - fn gas(_ctx: crate::wasm::Runtime, _amount: u32) -> Result<(), TrapReason> { + fn gas(_ctx: _, _memory: _, _amount: u32) -> Result<(), TrapReason> { Ok(()) } - fn nop(_ctx: crate::wasm::Runtime, _unused: u64) -> Result<(), TrapReason> { + fn nop(_ctx: _, _memory: _, _unused: u64) -> Result<(), TrapReason> { Ok(()) } - // new version of nop with other data type for argumebt + // new version of nop with other data type for argument #[version(1)] - fn nop(_ctx: crate::wasm::Runtime, _unused: i32) -> Result<(), TrapReason> { + fn nop(_ctx: _, _memory: _, _unused: i32) -> Result<(), TrapReason> { Ok(()) } } @@ -582,7 +631,13 @@ mod tests { }, .. Default::default() }; - let r = do_preparation::(wasm, &schedule, ALICE, Determinism::Deterministic); + let r = prepare::( + wasm, + &schedule, + ALICE, + Determinism::Deterministic, + TryInstantiate::Instantiate, + ); assert_matches::assert_matches!(r.map_err(|(_, msg)| msg), $($expected)*); } }; @@ -718,7 +773,7 @@ mod tests { (func (export "deploy")) ) "#, - Err("Module is not valid") + Err("validation of new code failed") ); prepare_test!( @@ -784,7 +839,7 @@ mod tests { (func (export "deploy")) ) "#, - Err("Module is not valid") + Err("validation of new code failed") ); prepare_test!( @@ -910,7 +965,7 @@ mod tests { (func (export "deploy")) ) "#, - Err("module imports a non-existent function") + Err("module imports a banned function") ); // memory is in "env" and not in "seal0" @@ -965,7 +1020,7 @@ mod tests { (func (export "deploy")) ) "#, - Err("module imports a non-existent function") + Err("module imports a banned function") ); prepare_test!( @@ -978,7 +1033,7 @@ mod tests { (func (export "deploy")) ) "#, - Err("module imports a non-existent function") + Err("new code rejected after instrumentation") ); } diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 281cc30c4f053..10a0cda569d75 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -21,25 +21,32 @@ use crate::{ exec::{ExecError, ExecResult, Ext, FixSizedKey, TopicOf, VarSizedKey}, gas::{ChargedAmount, Token}, schedule::HostFnWeights, - wasm::env_def::ConvertibleToWasm, BalanceOf, CodeHash, Config, Error, SENTINEL, }; use bitflags::bitflags; use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen}; -use frame_support::{dispatch::DispatchError, ensure, traits::Get, weights::Weight}; +use frame_support::{dispatch::DispatchError, ensure, traits::Get, weights::Weight, RuntimeDebug}; use pallet_contracts_primitives::{ExecReturnValue, ReturnFlags}; use pallet_contracts_proc_macro::define_env; use sp_core::crypto::UncheckedFrom; use sp_io::hashing::{blake2_128, blake2_256, keccak_256, sha2_256}; use sp_runtime::traits::{Bounded, Zero}; -use sp_sandbox::SandboxMemory; -use sp_std::prelude::*; -use wasm_instrument::parity_wasm::elements::ValueType; +use sp_std::{fmt, prelude::*}; +use wasmi::{core::HostError, errors::LinkerError, Linker, Memory, Store}; /// The maximum nesting depth a contract can use when encoding types. const MAX_DECODE_NESTING: u32 = 256; +/// Trait implemented by the [`define_env`] macro for the emitted `Env` struct. +pub trait Environment { + /// Adds all declared functions to the supplied [`Linker`] and [`Store`]. + fn define( + store: &mut Store, + linker: &mut Linker, + ) -> Result<(), LinkerError>; +} + /// Type of a storage key. #[allow(dead_code)] enum KeyType { @@ -104,19 +111,6 @@ pub enum ReturnCode { EcdsaRecoverFailed = 11, } -impl ConvertibleToWasm for ReturnCode { - const VALUE_TYPE: ValueType = ValueType::I32; - type NativeType = Self; - - fn to_typed_value(self) -> sp_sandbox::Value { - sp_sandbox::Value::I32(self as i32) - } - fn from_typed_value(_: sp_sandbox::Value) -> Option { - debug_assert!(false, "We will never receive a ReturnCode but only send it to wasm."); - None - } -} - impl From for ReturnCode { fn from(from: ExecReturnValue) -> Self { if from.flags.contains(ReturnFlags::REVERT) { @@ -127,7 +121,14 @@ impl From for ReturnCode { } } +impl From for u32 { + fn from(code: ReturnCode) -> u32 { + code as u32 + } +} + /// The data passed through when a contract uses `seal_return`. +#[derive(RuntimeDebug)] pub struct ReturnData { /// The flags as passed through by the contract. They are still unchecked and /// will later be parsed into a `ReturnFlags` bitflags struct. @@ -142,6 +143,7 @@ pub struct ReturnData { /// occurred (the SupervisorError variant). /// The other case is where the trap does not constitute an error but rather was invoked /// as a quick way to terminate the application (all other variants). +#[derive(RuntimeDebug)] pub enum TrapReason { /// The supervisor trapped the contract because of an error condition occurred during /// execution in privileged code. @@ -159,6 +161,14 @@ impl> From for TrapReason { } } +impl fmt::Display for TrapReason { + fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { + Ok(()) + } +} + +impl HostError for TrapReason {} + #[cfg_attr(test, derive(Debug, PartialEq, Eq))] #[derive(Copy, Clone)] pub enum RuntimeCosts { @@ -442,8 +452,7 @@ fn already_charged(_: u32) -> Option { pub struct Runtime<'a, E: Ext + 'a> { ext: &'a mut E, input_data: Option>, - memory: sp_sandbox::default_executor::Memory, - trap_reason: Option, + memory: Option, chain_extension: Option::ChainExtension>>, } @@ -453,58 +462,56 @@ where ::AccountId: UncheckedFrom<::Hash> + AsRef<[u8]>, { - pub fn new( - ext: &'a mut E, - input_data: Vec, - memory: sp_sandbox::default_executor::Memory, - ) -> Self { + pub fn new(ext: &'a mut E, input_data: Vec) -> Self { Runtime { ext, input_data: Some(input_data), - memory, - trap_reason: None, + memory: None, chain_extension: Some(Box::new(Default::default())), } } - /// Converts the sandbox result and the runtime state into the execution outcome. - /// - /// It evaluates information stored in the `trap_reason` variable of the runtime and - /// bases the outcome on the value if this variable. Only if `trap_reason` is `None` - /// the result of the sandbox is evaluated. - pub fn to_execution_result( - self, - sandbox_result: Result, - ) -> ExecResult { - // If a trap reason is set we base our decision solely on that. - if let Some(trap_reason) = self.trap_reason { - return match trap_reason { - // The trap was the result of the execution `return` host function. - TrapReason::Return(ReturnData { flags, data }) => { - let flags = - ReturnFlags::from_bits(flags).ok_or(Error::::InvalidCallFlags)?; - Ok(ExecReturnValue { flags, data }) - }, - TrapReason::Termination => - Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }), - TrapReason::SupervisorError(error) => return Err(error.into()), - } - } + pub fn memory(&self) -> Option { + self.memory + } - // Check the exact type of the error. + pub fn set_memory(&mut self, memory: Memory) { + self.memory = Some(memory); + } + + /// Converts the sandbox result and the runtime state into the execution outcome. + pub fn to_execution_result(self, sandbox_result: Result<(), wasmi::Error>) -> ExecResult { + use TrapReason::*; match sandbox_result { - // No traps were generated. Proceed normally. + // Contract returned from main function -> no data was returned. Ok(_) => Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }), - // `Error::Module` is returned only if instantiation or linking failed (i.e. + // Contract either trapped or some host function aborted the execution. + Err(wasmi::Error::Trap(trap)) => { + // If we encoded a reason then it is some abort generated by a host function. + // Otherwise the trap came from the contract. + let reason: TrapReason = *trap + .into_host() + .ok_or(Error::::ContractTrapped)? + .downcast() + .expect("`TrapReason` is the only type we use to encode host errors; qed"); + match reason { + Return(ReturnData { flags, data }) => { + let flags = + ReturnFlags::from_bits(flags).ok_or(Error::::InvalidCallFlags)?; + Ok(ExecReturnValue { flags, data }) + }, + Termination => + Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }), + SupervisorError(error) => return Err(error.into()), + } + }, + // Any other error is returned only if instantiation or linking failed (i.e. // wasm binary tried to import a function that is not provided by the host). // This shouldn't happen because validation process ought to reject such binaries. // // Because panics are really undesirable in the runtime code, we treat this as // a trap for now. Eventually, we might want to revisit this. - Err(sp_sandbox::Error::Module) => return Err("validation error".into()), - // Any other kind of a trap should result in a failure. - Err(sp_sandbox::Error::Execution) | Err(sp_sandbox::Error::OutOfBounds) => - return Err(Error::::ContractTrapped.into()), + Err(_) => Err(Error::::CodeRejected.into()), } } @@ -516,15 +523,6 @@ where self.ext } - /// Store the reason for a host function triggered trap. - /// - /// This is called by the `define_env` macro in order to store any error returned by - /// the host functions defined through the said macro. It should **not** be called - /// manually. - pub fn set_trap_reason(&mut self, reason: TrapReason) { - self.trap_reason = Some(reason); - } - /// Charge the gas meter with the specified token. /// /// Returns `Err(HostError)` if there is not enough gas. @@ -546,12 +544,15 @@ where /// Returns `Err` if one of the following conditions occurs: /// /// - requested buffer is not within the bounds of the sandbox memory. - pub fn read_sandbox_memory(&self, ptr: u32, len: u32) -> Result, DispatchError> { + pub fn read_sandbox_memory( + &self, + memory: &[u8], + ptr: u32, + len: u32, + ) -> Result, DispatchError> { ensure!(len <= self.ext.schedule().limits.max_memory_size(), Error::::OutOfBounds); let mut buf = vec![0u8; len as usize]; - self.memory - .get(ptr, buf.as_mut_slice()) - .map_err(|_| Error::::OutOfBounds)?; + self.read_sandbox_memory_into_buf(memory, ptr, buf.as_mut_slice())?; Ok(buf) } @@ -562,10 +563,15 @@ where /// - requested buffer is not within the bounds of the sandbox memory. pub fn read_sandbox_memory_into_buf( &self, + memory: &[u8], ptr: u32, buf: &mut [u8], ) -> Result<(), DispatchError> { - self.memory.get(ptr, buf).map_err(|_| Error::::OutOfBounds.into()) + let ptr = ptr as usize; + let bound_checked = + memory.get(ptr..ptr + buf.len()).ok_or_else(|| Error::::OutOfBounds)?; + buf.copy_from_slice(bound_checked); + Ok(()) } /// Reads and decodes a type with a size fixed at compile time from contract memory. @@ -576,10 +582,14 @@ where /// contract callable function. pub fn read_sandbox_memory_as( &self, + memory: &[u8], ptr: u32, ) -> Result { - let buf = self.read_sandbox_memory(ptr, D::max_encoded_len() as u32)?; - let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut &buf[..]) + let ptr = ptr as usize; + let mut bound_checked = memory + .get(ptr..ptr + D::max_encoded_len() as usize) + .ok_or_else(|| Error::::OutOfBounds)?; + let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked) .map_err(|_| DispatchError::from(Error::::DecodingFailed))?; Ok(decoded) } @@ -597,11 +607,14 @@ where /// regard to the overall weight. pub fn read_sandbox_memory_as_unbounded( &self, + memory: &[u8], ptr: u32, len: u32, ) -> Result { - let buf = self.read_sandbox_memory(ptr, len)?; - let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut &buf[..]) + let ptr = ptr as usize; + let mut bound_checked = + memory.get(ptr..ptr + len as usize).ok_or_else(|| Error::::OutOfBounds)?; + let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked) .map_err(|_| DispatchError::from(Error::::DecodingFailed))?; Ok(decoded) } @@ -627,6 +640,7 @@ where /// `Err` if the size of the buffer located at `out_ptr` is too small to fit `buf`. pub fn write_sandbox_output( &mut self, + memory: &mut [u8], out_ptr: u32, out_len_ptr: u32, buf: &[u8], @@ -638,7 +652,7 @@ where } let buf_len = buf.len() as u32; - let len: u32 = self.read_sandbox_memory_as(out_len_ptr)?; + let len: u32 = self.read_sandbox_memory_as(memory, out_len_ptr)?; if len < buf_len { return Err(Error::::OutputBufferTooSmall.into()) @@ -648,12 +662,8 @@ where self.charge_gas(costs)?; } - self.memory - .set(out_ptr, buf) - .and_then(|_| self.memory.set(out_len_ptr, &buf_len.encode())) - .map_err(|_| Error::::OutOfBounds)?; - - Ok(()) + self.write_sandbox_memory(memory, out_ptr, buf)?; + self.write_sandbox_memory(memory, out_len_ptr, &buf_len.encode()) } /// Write the given buffer to the designated location in the sandbox memory. @@ -661,8 +671,17 @@ where /// Returns `Err` if one of the following conditions occurs: /// /// - designated area is not within the bounds of the sandbox memory. - fn write_sandbox_memory(&mut self, ptr: u32, buf: &[u8]) -> Result<(), DispatchError> { - self.memory.set(ptr, buf).map_err(|_| Error::::OutOfBounds.into()) + fn write_sandbox_memory( + &mut self, + memory: &mut [u8], + ptr: u32, + buf: &[u8], + ) -> Result<(), DispatchError> { + let ptr = ptr as usize; + let bound_checked = + memory.get_mut(ptr..ptr + buf.len()).ok_or_else(|| Error::::OutOfBounds)?; + bound_checked.copy_from_slice(buf); + Ok(()) } /// Computes the given hash function on the supplied input. @@ -679,6 +698,7 @@ where /// The `input` and `output` buffers may overlap. fn compute_hash_on_intermediate_buffer( &mut self, + memory: &mut [u8], hash_fn: F, input_ptr: u32, input_len: u32, @@ -689,11 +709,11 @@ where R: AsRef<[u8]>, { // Copy input into supervisor memory. - let input = self.read_sandbox_memory(input_ptr, input_len)?; + let input = self.read_sandbox_memory(memory, input_ptr, input_len)?; // Compute the hash on the input buffer using the given hash function. let hash = hash_fn(&input); // Write the resulting hash back into the sandboxed output buffer. - self.write_sandbox_memory(output_ptr, hash.as_ref())?; + self.write_sandbox_memory(memory, output_ptr, hash.as_ref())?; Ok(()) } @@ -730,6 +750,7 @@ where fn set_storage( &mut self, + memory: &[u8], key_type: KeyType, key_ptr: u32, value_ptr: u32, @@ -741,8 +762,8 @@ where if value_len > max_size { return Err(Error::::ValueTooLarge.into()) } - let key = self.read_sandbox_memory(key_ptr, key_type.len::()?)?; - let value = Some(self.read_sandbox_memory(value_ptr, value_len)?); + let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::()?)?; + let value = Some(self.read_sandbox_memory(memory, value_ptr, value_len)?); let write_outcome = match key_type { KeyType::Fix => self.ext.set_storage( &FixSizedKey::try_from(key).map_err(|_| Error::::DecodingFailed)?, @@ -763,9 +784,14 @@ where Ok(write_outcome.old_len_with_sentinel()) } - fn clear_storage(&mut self, key_type: KeyType, key_ptr: u32) -> Result { + fn clear_storage( + &mut self, + memory: &[u8], + key_type: KeyType, + key_ptr: u32, + ) -> Result { let charged = self.charge_gas(RuntimeCosts::ClearStorage(self.ext.max_value_size()))?; - let key = self.read_sandbox_memory(key_ptr, key_type.len::()?)?; + let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::()?)?; let outcome = match key_type { KeyType::Fix => self.ext.set_storage( &FixSizedKey::try_from(key).map_err(|_| Error::::DecodingFailed)?, @@ -785,13 +811,14 @@ where fn get_storage( &mut self, + memory: &mut [u8], key_type: KeyType, key_ptr: u32, out_ptr: u32, out_len_ptr: u32, ) -> Result { let charged = self.charge_gas(RuntimeCosts::GetStorage(self.ext.max_value_size()))?; - let key = self.read_sandbox_memory(key_ptr, key_type.len::()?)?; + let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::()?)?; let outcome = match key_type { KeyType::Fix => self.ext.get_storage( &FixSizedKey::try_from(key).map_err(|_| Error::::DecodingFailed)?, @@ -803,7 +830,14 @@ where if let Some(value) = outcome { self.adjust_gas(charged, RuntimeCosts::GetStorage(value.len() as u32)); - self.write_sandbox_output(out_ptr, out_len_ptr, &value, false, already_charged)?; + self.write_sandbox_output( + memory, + out_ptr, + out_len_ptr, + &value, + false, + already_charged, + )?; Ok(ReturnCode::Success) } else { self.adjust_gas(charged, RuntimeCosts::GetStorage(0)); @@ -811,9 +845,14 @@ where } } - fn contains_storage(&mut self, key_type: KeyType, key_ptr: u32) -> Result { + fn contains_storage( + &mut self, + memory: &[u8], + key_type: KeyType, + key_ptr: u32, + ) -> Result { let charged = self.charge_gas(RuntimeCosts::ContainsStorage(self.ext.max_value_size()))?; - let key = self.read_sandbox_memory(key_ptr, key_type.len::()?)?; + let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::()?)?; let outcome = match key_type { KeyType::Fix => self.ext.get_storage_size( &FixSizedKey::try_from(key).map_err(|_| Error::::DecodingFailed)?, @@ -829,6 +868,7 @@ where fn call( &mut self, + memory: &mut [u8], flags: CallFlags, call_type: CallType, input_data_ptr: u32, @@ -845,14 +885,15 @@ where self.input_data.take().ok_or(Error::::InputForwarded)? } else { self.charge_gas(RuntimeCosts::CopyFromContract(input_data_len))?; - self.read_sandbox_memory(input_data_ptr, input_data_len)? + self.read_sandbox_memory(memory, input_data_ptr, input_data_len)? }; let call_outcome = match call_type { CallType::Call { callee_ptr, value_ptr, gas } => { let callee: <::T as frame_system::Config>::AccountId = - self.read_sandbox_memory_as(callee_ptr)?; - let value: BalanceOf<::T> = self.read_sandbox_memory_as(value_ptr)?; + self.read_sandbox_memory_as(memory, callee_ptr)?; + let value: BalanceOf<::T> = + self.read_sandbox_memory_as(memory, value_ptr)?; if value > 0u32.into() { self.charge_gas(RuntimeCosts::CallSurchargeTransfer)?; } @@ -868,7 +909,7 @@ where if flags.contains(CallFlags::ALLOW_REENTRY) { return Err(Error::::InvalidCallFlags.into()) } - let code_hash = self.read_sandbox_memory_as(code_hash_ptr)?; + let code_hash = self.read_sandbox_memory_as(memory, code_hash_ptr)?; self.ext.delegate_call(code_hash, input_data) }, }; @@ -885,15 +926,21 @@ where } if let Ok(output) = &call_outcome { - self.write_sandbox_output(output_ptr, output_len_ptr, &output.data, true, |len| { - Some(RuntimeCosts::CopyToContract(len)) - })?; + self.write_sandbox_output( + memory, + output_ptr, + output_len_ptr, + &output.data, + true, + |len| Some(RuntimeCosts::CopyToContract(len)), + )?; } Ok(Runtime::::exec_into_return_code(call_outcome)?) } fn instantiate( &mut self, + memory: &mut [u8], code_hash_ptr: u32, gas: u64, value_ptr: u32, @@ -908,17 +955,19 @@ where ) -> Result { let gas = Weight::from_ref_time(gas); self.charge_gas(RuntimeCosts::InstantiateBase { input_data_len, salt_len })?; - let value: BalanceOf<::T> = self.read_sandbox_memory_as(value_ptr)?; + let value: BalanceOf<::T> = self.read_sandbox_memory_as(memory, value_ptr)?; if value > 0u32.into() { self.charge_gas(RuntimeCosts::InstantiateSurchargeTransfer)?; } - let code_hash: CodeHash<::T> = self.read_sandbox_memory_as(code_hash_ptr)?; - let input_data = self.read_sandbox_memory(input_data_ptr, input_data_len)?; - let salt = self.read_sandbox_memory(salt_ptr, salt_len)?; + let code_hash: CodeHash<::T> = + self.read_sandbox_memory_as(memory, code_hash_ptr)?; + let input_data = self.read_sandbox_memory(memory, input_data_ptr, input_data_len)?; + let salt = self.read_sandbox_memory(memory, salt_ptr, salt_len)?; let instantiate_outcome = self.ext.instantiate(gas, code_hash, value, input_data, &salt); if let Ok((address, output)) = &instantiate_outcome { if !output.flags.contains(ReturnFlags::REVERT) { self.write_sandbox_output( + memory, address_ptr, address_len_ptr, &address.encode(), @@ -926,17 +975,22 @@ where already_charged, )?; } - self.write_sandbox_output(output_ptr, output_len_ptr, &output.data, true, |len| { - Some(RuntimeCosts::CopyToContract(len)) - })?; + self.write_sandbox_output( + memory, + output_ptr, + output_len_ptr, + &output.data, + true, + |len| Some(RuntimeCosts::CopyToContract(len)), + )?; } Ok(Runtime::::exec_into_return_code(instantiate_outcome.map(|(_, retval)| retval))?) } - fn terminate(&mut self, beneficiary_ptr: u32) -> Result<(), TrapReason> { + fn terminate(&mut self, memory: &[u8], beneficiary_ptr: u32) -> Result<(), TrapReason> { self.charge_gas(RuntimeCosts::Terminate)?; let beneficiary: <::T as frame_system::Config>::AccountId = - self.read_sandbox_memory_as(beneficiary_ptr)?; + self.read_sandbox_memory_as(memory, beneficiary_ptr)?; self.ext.terminate(&beneficiary)?; Err(TrapReason::Termination) } @@ -957,7 +1011,7 @@ pub mod env { /// This call is supposed to be called only by instrumentation injected code. /// /// - amount: How much gas is used. - fn gas(ctx: Runtime, amount: u64) -> Result<(), TrapReason> { + fn gas(ctx: _, _memory: _, amount: u64) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::MeteringBlock(amount))?; Ok(()) } @@ -968,12 +1022,13 @@ pub mod env { /// type. Still a valid thing to call when not interested in the return value. #[prefixed_alias] fn set_storage( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, value_ptr: u32, value_len: u32, ) -> Result<(), TrapReason> { - ctx.set_storage(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) + ctx.set_storage(memory, KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ()) } /// Set the value at the given key in the contract storage. @@ -997,12 +1052,13 @@ pub mod env { #[version(1)] #[prefixed_alias] fn set_storage( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, value_ptr: u32, value_len: u32, ) -> Result { - ctx.set_storage(KeyType::Fix, key_ptr, value_ptr, value_len) + ctx.set_storage(memory, KeyType::Fix, key_ptr, value_ptr, value_len) } /// Set the value at the given key in the contract storage. @@ -1024,13 +1080,14 @@ pub mod env { #[unstable] #[prefixed_alias] fn set_storage( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, key_len: u32, value_ptr: u32, value_len: u32, ) -> Result { - ctx.set_storage(KeyType::Variable(key_len), key_ptr, value_ptr, value_len) + ctx.set_storage(memory, KeyType::Variable(key_len), key_ptr, value_ptr, value_len) } /// Clear the value at the given key in the contract storage. @@ -1038,8 +1095,8 @@ pub mod env { /// Equivalent to the newer version of `seal_clear_storage` with the exception of the return /// type. Still a valid thing to call when not interested in the return value. #[prefixed_alias] - fn clear_storage(ctx: Runtime, key_ptr: u32) -> Result<(), TrapReason> { - ctx.clear_storage(KeyType::Fix, key_ptr).map(|_| ()) + fn clear_storage(ctx: _, memory: _, key_ptr: u32) -> Result<(), TrapReason> { + ctx.clear_storage(memory, KeyType::Fix, key_ptr).map(|_| ()) } /// Clear the value at the given key in the contract storage. @@ -1055,8 +1112,8 @@ pub mod env { /// `SENTINEL` is returned as a sentinel value. #[unstable] #[prefixed_alias] - fn clear_storage(ctx: Runtime, key_ptr: u32, key_len: u32) -> Result { - ctx.clear_storage(KeyType::Variable(key_len), key_ptr) + fn clear_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result { + ctx.clear_storage(memory, KeyType::Variable(key_len), key_ptr) } /// Retrieve the value under the given key from storage. @@ -1076,12 +1133,13 @@ pub mod env { /// `ReturnCode::KeyNotFound` #[prefixed_alias] fn get_storage( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, out_ptr: u32, out_len_ptr: u32, ) -> Result { - ctx.get_storage(KeyType::Fix, key_ptr, out_ptr, out_len_ptr) + ctx.get_storage(memory, KeyType::Fix, key_ptr, out_ptr, out_len_ptr) } /// Retrieve the value under the given key from storage. @@ -1105,13 +1163,14 @@ pub mod env { #[unstable] #[prefixed_alias] fn get_storage( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, key_len: u32, out_ptr: u32, out_len_ptr: u32, ) -> Result { - ctx.get_storage(KeyType::Variable(key_len), key_ptr, out_ptr, out_len_ptr) + ctx.get_storage(memory, KeyType::Variable(key_len), key_ptr, out_ptr, out_len_ptr) } /// Checks whether there is a value stored under the given key. @@ -1128,8 +1187,8 @@ pub mod env { /// Returns the size of the pre-existing value at the specified key if any. Otherwise /// `SENTINEL` is returned as a sentinel value. #[prefixed_alias] - fn contains_storage(ctx: Runtime, key_ptr: u32) -> Result { - ctx.contains_storage(KeyType::Fix, key_ptr) + fn contains_storage(ctx: _, memory: _, key_ptr: u32) -> Result { + ctx.contains_storage(memory, KeyType::Fix, key_ptr) } /// Checks whether there is a value stored under the given key. @@ -1147,8 +1206,8 @@ pub mod env { /// `SENTINEL` is returned as a sentinel value. #[unstable] #[prefixed_alias] - fn contains_storage(ctx: Runtime, key_ptr: u32, key_len: u32) -> Result { - ctx.contains_storage(KeyType::Variable(key_len), key_ptr) + fn contains_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result { + ctx.contains_storage(memory, KeyType::Variable(key_len), key_ptr) } /// Retrieve and remove the value under the given key from storage. @@ -1167,21 +1226,22 @@ pub mod env { #[unstable] #[prefixed_alias] fn take_storage( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, key_len: u32, out_ptr: u32, out_len_ptr: u32, ) -> Result { let charged = ctx.charge_gas(RuntimeCosts::TakeStorage(ctx.ext.max_value_size()))?; - let key = ctx.read_sandbox_memory(key_ptr, key_len)?; + let key = ctx.read_sandbox_memory(memory, key_ptr, key_len)?; if let crate::storage::WriteOutcome::Taken(value) = ctx.ext.set_storage_transparent( &VarSizedKey::::try_from(key).map_err(|_| Error::::DecodingFailed)?, None, true, )? { ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(value.len() as u32)); - ctx.write_sandbox_output(out_ptr, out_len_ptr, &value, false, already_charged)?; + ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &value, false, already_charged)?; Ok(ReturnCode::Success) } else { ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(0)); @@ -1204,7 +1264,8 @@ pub mod env { /// `ReturnCode::TransferFailed` #[prefixed_alias] fn transfer( - ctx: Runtime, + ctx: _, + memory: _, account_ptr: u32, _account_len: u32, value_ptr: u32, @@ -1212,8 +1273,8 @@ pub mod env { ) -> Result { ctx.charge_gas(RuntimeCosts::Transfer)?; let callee: <::T as frame_system::Config>::AccountId = - ctx.read_sandbox_memory_as(account_ptr)?; - let value: BalanceOf<::T> = ctx.read_sandbox_memory_as(value_ptr)?; + ctx.read_sandbox_memory_as(memory, account_ptr)?; + let value: BalanceOf<::T> = ctx.read_sandbox_memory_as(memory, value_ptr)?; let result = ctx.ext.transfer(&callee, value); match result { Ok(()) => Ok(ReturnCode::Success), @@ -1238,7 +1299,8 @@ pub mod env { /// compatibility. Consider switching to the newest version of this function. #[prefixed_alias] fn call( - ctx: Runtime, + ctx: _, + memory: _, callee_ptr: u32, _callee_len: u32, gas: u64, @@ -1250,6 +1312,7 @@ pub mod env { output_len_ptr: u32, ) -> Result { ctx.call( + memory, CallFlags::ALLOW_REENTRY, CallType::Call { callee_ptr, value_ptr, gas }, input_data_ptr, @@ -1291,7 +1354,8 @@ pub mod env { #[version(1)] #[prefixed_alias] fn call( - ctx: Runtime, + ctx: _, + memory: _, flags: u32, callee_ptr: u32, gas: u64, @@ -1302,6 +1366,7 @@ pub mod env { output_len_ptr: u32, ) -> Result { ctx.call( + memory, CallFlags::from_bits(flags).ok_or(Error::::InvalidCallFlags)?, CallType::Call { callee_ptr, value_ptr, gas }, input_data_ptr, @@ -1337,7 +1402,8 @@ pub mod env { /// `ReturnCode::CodeNotFound` #[prefixed_alias] fn delegate_call( - ctx: Runtime, + ctx: _, + memory: _, flags: u32, code_hash_ptr: u32, input_data_ptr: u32, @@ -1346,6 +1412,7 @@ pub mod env { output_len_ptr: u32, ) -> Result { ctx.call( + memory, CallFlags::from_bits(flags).ok_or(Error::::InvalidCallFlags)?, CallType::DelegateCall { code_hash_ptr }, input_data_ptr, @@ -1368,7 +1435,8 @@ pub mod env { /// compatibility. Consider switching to the newest version of this function. #[prefixed_alias] fn instantiate( - ctx: Runtime, + ctx: _, + memory: _, code_hash_ptr: u32, _code_hash_len: u32, gas: u64, @@ -1384,6 +1452,7 @@ pub mod env { salt_len: u32, ) -> Result { ctx.instantiate( + memory, code_hash_ptr, gas, value_ptr, @@ -1441,7 +1510,8 @@ pub mod env { #[version(1)] #[prefixed_alias] fn instantiate( - ctx: Runtime, + ctx: _, + memory: _, code_hash_ptr: u32, gas: u64, value_ptr: u32, @@ -1455,6 +1525,7 @@ pub mod env { salt_len: u32, ) -> Result { ctx.instantiate( + memory, code_hash_ptr, gas, value_ptr, @@ -1483,11 +1554,12 @@ pub mod env { /// compatibility. Consider switching to the newest version of this function. #[prefixed_alias] fn terminate( - ctx: Runtime, + ctx: _, + memory: _, beneficiary_ptr: u32, _beneficiary_len: u32, ) -> Result<(), TrapReason> { - ctx.terminate(beneficiary_ptr) + ctx.terminate(memory, beneficiary_ptr) } /// Remove the calling account and transfer remaining **free** balance. @@ -1507,8 +1579,8 @@ pub mod env { /// - The deletion queue is full. #[version(1)] #[prefixed_alias] - fn terminate(ctx: Runtime, beneficiary_ptr: u32) -> Result<(), TrapReason> { - ctx.terminate(beneficiary_ptr) + fn terminate(ctx: _, memory: _, beneficiary_ptr: u32) -> Result<(), TrapReason> { + ctx.terminate(memory, beneficiary_ptr) } /// Stores the input passed by the caller into the supplied buffer. @@ -1522,10 +1594,10 @@ pub mod env { /// /// This function traps if the input was previously forwarded by a `seal_call`. #[prefixed_alias] - fn input(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + 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(out_ptr, out_len_ptr, &input, false, |len| { + ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &input, false, |len| { Some(RuntimeCosts::CopyToContract(len)) })?; ctx.input_data = Some(input); @@ -1553,7 +1625,8 @@ pub mod env { /// /// Using a reserved bit triggers a trap. fn seal_return( - ctx: Runtime, + ctx: _, + memory: _, flags: u32, data_ptr: u32, data_len: u32, @@ -1561,7 +1634,7 @@ pub mod env { ctx.charge_gas(RuntimeCosts::Return(data_len))?; Err(TrapReason::Return(ReturnData { flags, - data: ctx.read_sandbox_memory(data_ptr, data_len)?, + data: ctx.read_sandbox_memory(memory, data_ptr, data_len)?, })) } @@ -1576,9 +1649,10 @@ pub mod env { /// extrinsic will be returned. Otherwise, if this call is initiated by another contract then /// the address of the contract will be returned. The value is encoded as T::AccountId. #[prefixed_alias] - fn caller(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn caller(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::Caller)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.caller().encode(), @@ -1596,10 +1670,10 @@ pub mod env { /// /// Returned value is a u32-encoded boolean: (0 = false, 1 = true). #[prefixed_alias] - fn is_contract(ctx: Runtime, account_ptr: u32) -> Result { + fn is_contract(ctx: _, memory: _, account_ptr: u32) -> Result { ctx.charge_gas(RuntimeCosts::IsContract)?; let address: <::T as frame_system::Config>::AccountId = - ctx.read_sandbox_memory_as(account_ptr)?; + ctx.read_sandbox_memory_as(memory, account_ptr)?; Ok(ctx.ext.is_contract(&address) as u32) } @@ -1619,16 +1693,18 @@ pub mod env { /// `ReturnCode::KeyNotFound` #[prefixed_alias] fn code_hash( - ctx: Runtime, + ctx: _, + memory: _, account_ptr: u32, out_ptr: u32, out_len_ptr: u32, ) -> Result { ctx.charge_gas(RuntimeCosts::CodeHash)?; let address: <::T as frame_system::Config>::AccountId = - ctx.read_sandbox_memory_as(account_ptr)?; + ctx.read_sandbox_memory_as(memory, account_ptr)?; if let Some(value) = ctx.ext.code_hash(&address) { ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &value.encode(), @@ -1649,10 +1725,11 @@ pub mod env { /// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and /// the value length is written to. #[prefixed_alias] - fn own_code_hash(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn own_code_hash(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::OwnCodeHash)?; let code_hash_encoded = &ctx.ext.own_code_hash().encode(); Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, code_hash_encoded, @@ -1672,7 +1749,7 @@ pub mod env { /// /// Returned value is a u32-encoded boolean: (0 = false, 1 = true). #[prefixed_alias] - fn caller_is_origin(ctx: Runtime) -> Result { + fn caller_is_origin(ctx: _, _memory: _) -> Result { ctx.charge_gas(RuntimeCosts::CallerIsOrigin)?; Ok(ctx.ext.caller_is_origin() as u32) } @@ -1684,9 +1761,10 @@ pub mod env { /// `out_ptr`. This call overwrites it with the size of the value. If the available /// space at `out_ptr` is less than the size of the value a trap is triggered. #[prefixed_alias] - fn address(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn address(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::Address)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.address().encode(), @@ -1710,7 +1788,8 @@ pub mod env { /// gas can be smaller than one. #[prefixed_alias] fn weight_to_fee( - ctx: Runtime, + ctx: _, + memory: _, gas: u64, out_ptr: u32, out_len_ptr: u32, @@ -1718,6 +1797,7 @@ pub mod env { let gas = Weight::from_ref_time(gas); ctx.charge_gas(RuntimeCosts::WeightToFee)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.get_weight_price(gas).encode(), @@ -1735,10 +1815,17 @@ pub mod env { /// /// The data is encoded as Gas. #[prefixed_alias] - fn gas_left(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn gas_left(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::GasLeft)?; let gas_left = &ctx.ext.gas_meter().gas_left().ref_time().encode(); - Ok(ctx.write_sandbox_output(out_ptr, out_len_ptr, gas_left, false, already_charged)?) + Ok(ctx.write_sandbox_output( + memory, + out_ptr, + out_len_ptr, + gas_left, + false, + already_charged, + )?) } /// Stores the **free* balance of the current account into the supplied buffer. @@ -1750,9 +1837,10 @@ pub mod env { /// /// The data is encoded as T::Balance. #[prefixed_alias] - fn balance(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn balance(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::Balance)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.balance().encode(), @@ -1771,12 +1859,14 @@ pub mod env { /// The data is encoded as T::Balance. #[prefixed_alias] fn value_transferred( - ctx: Runtime, + ctx: _, + memory: _, out_ptr: u32, out_len_ptr: u32, ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::ValueTransferred)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.value_transferred().encode(), @@ -1799,7 +1889,8 @@ pub mod env { /// This function is deprecated. Users should migrate to the version in the "seal1" module. #[prefixed_alias] fn random( - ctx: Runtime, + ctx: _, + memory: _, subject_ptr: u32, subject_len: u32, out_ptr: u32, @@ -1809,8 +1900,9 @@ pub mod env { if subject_len > ctx.ext.schedule().limits.subject_len { return Err(Error::::RandomSubjectTooLong.into()) } - let subject_buf = ctx.read_sandbox_memory(subject_ptr, subject_len)?; + let subject_buf = ctx.read_sandbox_memory(memory, subject_ptr, subject_len)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.random(&subject_buf).0.encode(), @@ -1843,7 +1935,8 @@ pub mod env { #[version(1)] #[prefixed_alias] fn random( - ctx: Runtime, + ctx: _, + memory: _, subject_ptr: u32, subject_len: u32, out_ptr: u32, @@ -1853,8 +1946,9 @@ pub mod env { if subject_len > ctx.ext.schedule().limits.subject_len { return Err(Error::::RandomSubjectTooLong.into()) } - let subject_buf = ctx.read_sandbox_memory(subject_ptr, subject_len)?; + let subject_buf = ctx.read_sandbox_memory(memory, subject_ptr, subject_len)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.random(&subject_buf).encode(), @@ -1870,9 +1964,10 @@ pub mod env { /// `out_ptr`. This call overwrites it with the size of the value. If the available /// space at `out_ptr` is less than the size of the value a trap is triggered. #[prefixed_alias] - fn now(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn now(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::Now)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.now().encode(), @@ -1885,9 +1980,15 @@ pub mod env { /// /// The data is encoded as T::Balance. #[prefixed_alias] - fn minimum_balance(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn minimum_balance( + ctx: _, + memory: _, + out_ptr: u32, + out_len_ptr: u32, + ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::MinimumBalance)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.minimum_balance().encode(), @@ -1908,13 +2009,21 @@ pub mod env { /// There is no longer a tombstone deposit. This function always returns 0. #[prefixed_alias] fn tombstone_deposit( - ctx: Runtime, + ctx: _, + memory: _, out_ptr: u32, out_len_ptr: u32, ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::Balance)?; let deposit = >::zero().encode(); - Ok(ctx.write_sandbox_output(out_ptr, out_len_ptr, &deposit, false, already_charged)?) + Ok(ctx.write_sandbox_output( + memory, + out_ptr, + out_len_ptr, + &deposit, + false, + already_charged, + )?) } /// Was used to restore the given destination contract sacrificing the caller. @@ -1925,7 +2034,8 @@ pub mod env { /// backwards compatiblity #[prefixed_alias] fn restore_to( - ctx: Runtime, + ctx: _, + memory: _, _dest_ptr: u32, _dest_len: u32, _code_hash_ptr: u32, @@ -1948,7 +2058,8 @@ pub mod env { #[version(1)] #[prefixed_alias] fn restore_to( - ctx: Runtime, + ctx: _, + memory: _, _dest_ptr: u32, _code_hash_ptr: u32, _rent_allowance_ptr: u32, @@ -1969,7 +2080,8 @@ pub mod env { /// - data_len - the length of the data buffer. #[prefixed_alias] fn deposit_event( - ctx: Runtime, + ctx: _, + memory: _, topics_ptr: u32, topics_len: u32, data_ptr: u32, @@ -1994,7 +2106,7 @@ pub mod env { let mut topics: Vec::T>> = match topics_len { 0 => Vec::new(), - _ => ctx.read_sandbox_memory_as_unbounded(topics_ptr, topics_len)?, + _ => ctx.read_sandbox_memory_as_unbounded(memory, topics_ptr, topics_len)?, }; // If there are more than `event_topics`, then trap. @@ -2009,7 +2121,7 @@ pub mod env { return Err(Error::::DuplicateTopics.into()) } - let event_data = ctx.read_sandbox_memory(data_ptr, data_len)?; + let event_data = ctx.read_sandbox_memory(memory, data_ptr, data_len)?; ctx.ext.deposit_event(topics, event_data); @@ -2024,7 +2136,8 @@ pub mod env { /// backwards compatiblity. #[prefixed_alias] fn set_rent_allowance( - ctx: Runtime, + ctx: _, + memory: _, _value_ptr: u32, _value_len: u32, ) -> Result<(), TrapReason> { @@ -2040,7 +2153,7 @@ pub mod env { /// backwards compatiblity. #[version(1)] #[prefixed_alias] - fn set_rent_allowance(ctx: Runtime, _value_ptr: u32) -> Result<(), TrapReason> { + fn set_rent_allowance(ctx: _, _memory: _, _value_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::DebugMessage)?; Ok(()) } @@ -2052,10 +2165,11 @@ pub mod env { /// The state rent functionality was removed. This is stub only exists for /// backwards compatiblity. #[prefixed_alias] - fn rent_allowance(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn rent_allowance(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::Balance)?; let rent_allowance = >::max_value().encode(); Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &rent_allowance, @@ -2071,9 +2185,10 @@ pub mod env { /// `out_ptr`. This call overwrites it with the size of the value. If the available /// space at `out_ptr` is less than the size of the value a trap is triggered. #[prefixed_alias] - fn block_number(ctx: Runtime, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { + fn block_number(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::BlockNumber)?; Ok(ctx.write_sandbox_output( + memory, out_ptr, out_len_ptr, &ctx.ext.block_number().encode(), @@ -2101,13 +2216,16 @@ pub mod env { /// function will write the result directly into this buffer. #[prefixed_alias] fn hash_sha2_256( - ctx: Runtime, + ctx: _, + memory: _, input_ptr: u32, input_len: u32, output_ptr: u32, ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::HashSha256(input_len))?; - Ok(ctx.compute_hash_on_intermediate_buffer(sha2_256, input_ptr, input_len, output_ptr)?) + Ok(ctx.compute_hash_on_intermediate_buffer( + memory, sha2_256, input_ptr, input_len, output_ptr, + )?) } /// Computes the KECCAK 256-bit hash on the given input buffer. @@ -2129,13 +2247,16 @@ pub mod env { /// function will write the result directly into this buffer. #[prefixed_alias] fn hash_keccak_256( - ctx: Runtime, + ctx: _, + memory: _, input_ptr: u32, input_len: u32, output_ptr: u32, ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::HashKeccak256(input_len))?; - Ok(ctx.compute_hash_on_intermediate_buffer(keccak_256, input_ptr, input_len, output_ptr)?) + Ok(ctx.compute_hash_on_intermediate_buffer( + memory, keccak_256, input_ptr, input_len, output_ptr, + )?) } /// Computes the BLAKE2 256-bit hash on the given input buffer. @@ -2157,13 +2278,16 @@ pub mod env { /// function will write the result directly into this buffer. #[prefixed_alias] fn hash_blake2_256( - ctx: Runtime, + ctx: _, + memory: _, input_ptr: u32, input_len: u32, output_ptr: u32, ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::HashBlake256(input_len))?; - Ok(ctx.compute_hash_on_intermediate_buffer(blake2_256, input_ptr, input_len, output_ptr)?) + Ok(ctx.compute_hash_on_intermediate_buffer( + memory, blake2_256, input_ptr, input_len, output_ptr, + )?) } /// Computes the BLAKE2 128-bit hash on the given input buffer. @@ -2185,13 +2309,16 @@ pub mod env { /// function will write the result directly into this buffer. #[prefixed_alias] fn hash_blake2_128( - ctx: Runtime, + ctx: _, + memory: _, input_ptr: u32, input_len: u32, output_ptr: u32, ) -> Result<(), TrapReason> { ctx.charge_gas(RuntimeCosts::HashBlake128(input_len))?; - Ok(ctx.compute_hash_on_intermediate_buffer(blake2_128, input_ptr, input_len, output_ptr)?) + Ok(ctx.compute_hash_on_intermediate_buffer( + memory, blake2_128, input_ptr, input_len, output_ptr, + )?) } /// Call into the chain extension provided by the chain if any. @@ -2207,7 +2334,8 @@ pub mod env { /// module error. #[prefixed_alias] fn call_chain_extension( - ctx: Runtime, + ctx: _, + memory: _, id: u32, input_ptr: u32, input_len: u32, @@ -2222,7 +2350,8 @@ pub mod env { "Constructor initializes with `Some`. This is the only place where it is set to `None`.\ It is always reset to `Some` afterwards. qed" ); - let env = Environment::new(ctx, id, input_ptr, input_len, output_ptr, output_len_ptr); + let env = + Environment::new(ctx, memory, id, input_ptr, input_len, output_ptr, output_len_ptr); let ret = match chain_extension.call(env)? { RetVal::Converging(val) => Ok(val), RetVal::Diverging { flags, data } => @@ -2251,13 +2380,14 @@ pub mod env { /// return value of this function can be cached in order to prevent further calls at runtime. #[prefixed_alias] fn debug_message( - ctx: Runtime, + ctx: _, + memory: _, str_ptr: u32, str_len: u32, ) -> Result { ctx.charge_gas(RuntimeCosts::DebugMessage)?; if ctx.ext.append_debug_buffer("") { - let data = ctx.read_sandbox_memory(str_ptr, str_len)?; + let data = ctx.read_sandbox_memory(memory, str_ptr, str_len)?; let msg = core::str::from_utf8(&data).map_err(|_| >::DebugMessageInvalidUTF8)?; ctx.ext.append_debug_buffer(msg); @@ -2306,14 +2436,15 @@ pub mod env { #[unstable] #[prefixed_alias] fn call_runtime( - ctx: Runtime, + ctx: _, + memory: _, call_ptr: u32, call_len: u32, ) -> Result { use frame_support::dispatch::{extract_actual_weight, GetDispatchInfo}; ctx.charge_gas(RuntimeCosts::CopyFromContract(call_len))?; let call: ::RuntimeCall = - ctx.read_sandbox_memory_as_unbounded(call_ptr, call_len)?; + ctx.read_sandbox_memory_as_unbounded(memory, call_ptr, call_len)?; let dispatch_info = call.get_dispatch_info(); let charged = ctx.charge_gas(RuntimeCosts::CallRuntime(dispatch_info.weight))?; let result = ctx.ext.call_runtime(call); @@ -2344,7 +2475,8 @@ pub mod env { /// `ReturnCode::EcdsaRecoverFailed` #[prefixed_alias] fn ecdsa_recover( - ctx: Runtime, + ctx: _, + memory: _, signature_ptr: u32, message_hash_ptr: u32, output_ptr: u32, @@ -2352,9 +2484,9 @@ pub mod env { ctx.charge_gas(RuntimeCosts::EcdsaRecovery)?; let mut signature: [u8; 65] = [0; 65]; - ctx.read_sandbox_memory_into_buf(signature_ptr, &mut signature)?; + ctx.read_sandbox_memory_into_buf(memory, signature_ptr, &mut signature)?; let mut message_hash: [u8; 32] = [0; 32]; - ctx.read_sandbox_memory_into_buf(message_hash_ptr, &mut message_hash)?; + ctx.read_sandbox_memory_into_buf(memory, message_hash_ptr, &mut message_hash)?; let result = ctx.ext.ecdsa_recover(&signature, &message_hash); @@ -2362,7 +2494,7 @@ pub mod env { Ok(pub_key) => { // Write the recovered compressed ecdsa public key back into the sandboxed output // buffer. - ctx.write_sandbox_memory(output_ptr, pub_key.as_ref())?; + ctx.write_sandbox_memory(memory, output_ptr, pub_key.as_ref())?; Ok(ReturnCode::Success) }, @@ -2398,9 +2530,10 @@ pub mod env { /// /// `ReturnCode::CodeNotFound` #[prefixed_alias] - fn set_code_hash(ctx: Runtime, code_hash_ptr: u32) -> Result { + fn set_code_hash(ctx: _, memory: _, code_hash_ptr: u32) -> Result { ctx.charge_gas(RuntimeCosts::SetCodeHash)?; - let code_hash: CodeHash<::T> = ctx.read_sandbox_memory_as(code_hash_ptr)?; + let code_hash: CodeHash<::T> = + ctx.read_sandbox_memory_as(memory, code_hash_ptr)?; match ctx.ext.set_code_hash(code_hash) { Err(err) => { let code = Runtime::::err_into_return_code(err)?; @@ -2428,17 +2561,18 @@ pub mod env { /// `ReturnCode::EcdsaRecoverFailed` #[prefixed_alias] fn ecdsa_to_eth_address( - ctx: Runtime, + ctx: _, + memory: _, key_ptr: u32, out_ptr: u32, ) -> Result { ctx.charge_gas(RuntimeCosts::EcdsaToEthAddress)?; let mut compressed_key: [u8; 33] = [0; 33]; - ctx.read_sandbox_memory_into_buf(key_ptr, &mut compressed_key)?; + ctx.read_sandbox_memory_into_buf(memory, key_ptr, &mut compressed_key)?; let result = ctx.ext.ecdsa_to_eth_address(&compressed_key); match result { Ok(eth_address) => { - ctx.write_sandbox_memory(out_ptr, eth_address.as_ref())?; + ctx.write_sandbox_memory(memory, out_ptr, eth_address.as_ref())?; Ok(ReturnCode::Success) }, Err(_) => Ok(ReturnCode::EcdsaRecoverFailed), From 8198e3585943ed245a55993b186ab921da0bd3a7 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Fri, 28 Oct 2022 17:22:03 +0000 Subject: [PATCH 02/27] ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts --- frame/contracts/src/weights.rs | 1693 ++++++++++++++++++-------------- 1 file changed, 961 insertions(+), 732 deletions(-) diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index 46c86b670a7fe..168bd25f3a7c9 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -7,7 +7,7 @@ // 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 +// 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, @@ -18,7 +18,7 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-10-19, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-10-28, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 @@ -35,6 +35,7 @@ // --json-file=/var/lib/gitlab-runner/builds/zyw4fam_/0/parity/mirrors/substrate/.git/.artifacts/bench.json // --pallet=pallet_contracts // --chain=dev +// --header=./HEADER-APACHE2 // --output=./frame/contracts/src/weights.rs // --template=./.maintain/frame-weight-template.hbs @@ -167,15 +168,17 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - Weight::from_ref_time(3_108_000 as u64) + // Minimum execution time: 2_919 nanoseconds. + Weight::from_ref_time(3_033_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - Weight::from_ref_time(15_377_000 as u64) - // Standard Error: 414 - .saturating_add(Weight::from_ref_time(892_761 as u64).saturating_mul(k as u64)) + // Minimum execution time: 14_627 nanoseconds. + Weight::from_ref_time(16_018_897 as u64) + // Standard Error: 824 + .saturating_add(Weight::from_ref_time(893_332 as u64).saturating_mul(k as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -183,18 +186,21 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - Weight::from_ref_time(3_127_000 as u64) - // Standard Error: 3_813 - .saturating_add(Weight::from_ref_time(1_379_402 as u64).saturating_mul(q as u64)) + // Minimum execution time: 2_867 nanoseconds. + Weight::from_ref_time(13_411_793 as u64) + // Standard Error: 5_268 + .saturating_add(Weight::from_ref_time(1_244_288 as u64).saturating_mul(q as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: Contracts PristineCode (r:1 w:0) // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - Weight::from_ref_time(22_849_000 as u64) - // Standard Error: 26 - .saturating_add(Weight::from_ref_time(45_513 as u64).saturating_mul(c as u64)) + // Minimum execution time: 20_987 nanoseconds. + Weight::from_ref_time(24_245_898 as u64) + // Standard Error: 48 + .saturating_add(Weight::from_ref_time(34_792 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -205,9 +211,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - Weight::from_ref_time(258_275_000 as u64) - // Standard Error: 30 - .saturating_add(Weight::from_ref_time(45_885 as u64).saturating_mul(c as u64)) + // Minimum execution time: 299_074 nanoseconds. + Weight::from_ref_time(306_372_889 as u64) + // Standard Error: 25 + .saturating_add(Weight::from_ref_time(30_663 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -222,11 +229,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - Weight::from_ref_time(2_115_889_000 as u64) - // Standard Error: 323 - .saturating_add(Weight::from_ref_time(89_541 as u64).saturating_mul(c as u64)) - // Standard Error: 19 - .saturating_add(Weight::from_ref_time(664 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_072_174 nanoseconds. + Weight::from_ref_time(337_874_723 as u64) + // Standard Error: 73 + .saturating_add(Weight::from_ref_time(88_343 as u64).saturating_mul(c as u64)) + // Standard Error: 4 + .saturating_add(Weight::from_ref_time(1_695 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } @@ -239,9 +247,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - Weight::from_ref_time(211_349_000 as u64) + // Minimum execution time: 178_787 nanoseconds. + Weight::from_ref_time(171_072_954 as u64) // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_532 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_447 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } @@ -251,7 +260,8 @@ impl WeightInfo for SubstrateWeight { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - Weight::from_ref_time(181_771_000 as u64) + // Minimum execution time: 147_880 nanoseconds. + Weight::from_ref_time(149_054_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -261,9 +271,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - Weight::from_ref_time(55_917_000 as u64) - // Standard Error: 25 - .saturating_add(Weight::from_ref_time(46_148 as u64).saturating_mul(c as u64)) + // Minimum execution time: 281_951 nanoseconds. + Weight::from_ref_time(296_591_045 as u64) + // Standard Error: 59 + .saturating_add(Weight::from_ref_time(75_741 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -272,7 +283,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - Weight::from_ref_time(37_966_000 as u64) + // Minimum execution time: 38_314 nanoseconds. + Weight::from_ref_time(39_208_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -280,7 +292,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - Weight::from_ref_time(40_963_000 as u64) + // Minimum execution time: 40_821 nanoseconds. + Weight::from_ref_time(41_085_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } @@ -291,9 +304,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - Weight::from_ref_time(247_526_000 as u64) - // Standard Error: 29_505 - .saturating_add(Weight::from_ref_time(35_107_467 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_566 nanoseconds. + Weight::from_ref_time(291_662_997 as u64) + // Standard Error: 26_198 + .saturating_add(Weight::from_ref_time(15_812_705 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -304,9 +318,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - Weight::from_ref_time(253_782_000 as u64) - // Standard Error: 256_004 - .saturating_add(Weight::from_ref_time(201_621_188 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_050 nanoseconds. + Weight::from_ref_time(231_589_172 as u64) + // Standard Error: 457_107 + .saturating_add(Weight::from_ref_time(194_493_604 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -318,9 +333,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - Weight::from_ref_time(249_892_000 as u64) - // Standard Error: 234_750 - .saturating_add(Weight::from_ref_time(258_209_168 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_561 nanoseconds. + Weight::from_ref_time(241_544_282 as u64) + // Standard Error: 439_485 + .saturating_add(Weight::from_ref_time(234_068_306 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -332,9 +348,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - Weight::from_ref_time(248_674_000 as u64) - // Standard Error: 23_962 - .saturating_add(Weight::from_ref_time(38_319_695 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_800 nanoseconds. + Weight::from_ref_time(292_300_021 as u64) + // Standard Error: 40_833 + .saturating_add(Weight::from_ref_time(19_473_073 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -345,9 +362,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - Weight::from_ref_time(244_345_000 as u64) - // Standard Error: 15_429 - .saturating_add(Weight::from_ref_time(14_751_125 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_811 nanoseconds. + Weight::from_ref_time(289_605_062 as u64) + // Standard Error: 17_481 + .saturating_add(Weight::from_ref_time(11_088_146 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -358,9 +376,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - Weight::from_ref_time(247_045_000 as u64) - // Standard Error: 25_949 - .saturating_add(Weight::from_ref_time(35_001_004 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_389 nanoseconds. + Weight::from_ref_time(291_607_958 as u64) + // Standard Error: 33_895 + .saturating_add(Weight::from_ref_time(15_781_940 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -371,9 +390,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - Weight::from_ref_time(247_176_000 as u64) - // Standard Error: 24_500 - .saturating_add(Weight::from_ref_time(34_447_506 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_896 nanoseconds. + Weight::from_ref_time(289_802_376 as u64) + // Standard Error: 33_013 + .saturating_add(Weight::from_ref_time(15_705_525 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -384,10 +404,11 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - Weight::from_ref_time(247_278_000 as u64) - // Standard Error: 48_613 - .saturating_add(Weight::from_ref_time(108_381_432 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 284_380 nanoseconds. + Weight::from_ref_time(291_136_750 as u64) + // Standard Error: 92_026 + .saturating_add(Weight::from_ref_time(86_938_178 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) @@ -397,9 +418,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - Weight::from_ref_time(246_996_000 as u64) - // Standard Error: 24_585 - .saturating_add(Weight::from_ref_time(34_615_777 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_734 nanoseconds. + Weight::from_ref_time(290_556_604 as u64) + // Standard Error: 31_726 + .saturating_add(Weight::from_ref_time(15_580_656 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -410,9 +432,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - Weight::from_ref_time(247_207_000 as u64) - // Standard Error: 30_691 - .saturating_add(Weight::from_ref_time(34_626_552 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_935 nanoseconds. + Weight::from_ref_time(290_693_236 as u64) + // Standard Error: 24_862 + .saturating_add(Weight::from_ref_time(15_421_306 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -423,9 +446,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - Weight::from_ref_time(247_538_000 as u64) - // Standard Error: 27_128 - .saturating_add(Weight::from_ref_time(34_277_292 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_010 nanoseconds. + Weight::from_ref_time(290_738_164 as u64) + // Standard Error: 20_205 + .saturating_add(Weight::from_ref_time(15_237_554 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -436,9 +460,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - Weight::from_ref_time(247_398_000 as u64) - // Standard Error: 28_375 - .saturating_add(Weight::from_ref_time(34_573_437 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_862 nanoseconds. + Weight::from_ref_time(291_029_188 as u64) + // Standard Error: 30_491 + .saturating_add(Weight::from_ref_time(15_450_941 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -450,10 +475,11 @@ impl WeightInfo for SubstrateWeight { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - Weight::from_ref_time(247_732_000 as u64) - // Standard Error: 42_671 - .saturating_add(Weight::from_ref_time(123_110_886 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 283_725 nanoseconds. + Weight::from_ref_time(293_071_360 as u64) + // Standard Error: 97_620 + .saturating_add(Weight::from_ref_time(85_454_560 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) @@ -463,9 +489,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - Weight::from_ref_time(170_547_000 as u64) - // Standard Error: 9_163 - .saturating_add(Weight::from_ref_time(15_589_088 as u64).saturating_mul(r as u64)) + // Minimum execution time: 135_545 nanoseconds. + Weight::from_ref_time(139_022_047 as u64) + // Standard Error: 9_547 + .saturating_add(Weight::from_ref_time(7_859_219 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -476,9 +503,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - Weight::from_ref_time(247_264_000 as u64) - // Standard Error: 23_913 - .saturating_add(Weight::from_ref_time(32_753_431 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_396 nanoseconds. + Weight::from_ref_time(291_462_361 as u64) + // Standard Error: 28_397 + .saturating_add(Weight::from_ref_time(13_492_690 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -489,9 +517,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(282_721_000 as u64) - // Standard Error: 1_978 - .saturating_add(Weight::from_ref_time(9_625_699 as u64).saturating_mul(n as u64)) + // Minimum execution time: 302_871 nanoseconds. + Weight::from_ref_time(320_897_273 as u64) + // Standard Error: 3_496 + .saturating_add(Weight::from_ref_time(9_614_024 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -502,9 +531,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - Weight::from_ref_time(244_356_000 as u64) - // Standard Error: 184_002 - .saturating_add(Weight::from_ref_time(2_423_400 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_519 nanoseconds. + Weight::from_ref_time(286_177_785 as u64) + // Standard Error: 101_357 + .saturating_add(Weight::from_ref_time(888_714 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -515,9 +545,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(246_157_000 as u64) - // Standard Error: 324 - .saturating_add(Weight::from_ref_time(188_687 as u64).saturating_mul(n as u64)) + // Minimum execution time: 285_901 nanoseconds. + Weight::from_ref_time(287_315_127 as u64) + // Standard Error: 877 + .saturating_add(Weight::from_ref_time(190_891 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -530,9 +561,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - Weight::from_ref_time(247_356_000 as u64) - // Standard Error: 232_552 - .saturating_add(Weight::from_ref_time(55_027_099 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_147 nanoseconds. + Weight::from_ref_time(287_753_920 as u64) + // Standard Error: 99_065 + .saturating_add(Weight::from_ref_time(53_786_379 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -546,10 +578,11 @@ impl WeightInfo for SubstrateWeight { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - Weight::from_ref_time(247_069_000 as u64) - // Standard Error: 59_538 - .saturating_add(Weight::from_ref_time(128_858_347 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 282_779 nanoseconds. + Weight::from_ref_time(295_701_851 as u64) + // Standard Error: 92_851 + .saturating_add(Weight::from_ref_time(106_176_241 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) @@ -559,9 +592,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - Weight::from_ref_time(244_659_000 as u64) - // Standard Error: 70_677 - .saturating_add(Weight::from_ref_time(239_930_533 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_392 nanoseconds. + Weight::from_ref_time(296_151_487 as u64) + // Standard Error: 117_012 + .saturating_add(Weight::from_ref_time(222_546_893 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -573,11 +607,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - Weight::from_ref_time(1_198_350_000 as u64) - // Standard Error: 2_049_556 - .saturating_add(Weight::from_ref_time(70_072_141 as u64).saturating_mul(t as u64)) - // Standard Error: 496_378 - .saturating_add(Weight::from_ref_time(35_566_752 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_192_807 nanoseconds. + Weight::from_ref_time(506_881_525 as u64) + // Standard Error: 443_155 + .saturating_add(Weight::from_ref_time(177_724_866 as u64).saturating_mul(t as u64)) + // Standard Error: 121_711 + .saturating_add(Weight::from_ref_time(67_213_725 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -590,18 +625,20 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - Weight::from_ref_time(177_240_000 as u64) - // Standard Error: 18_991 - .saturating_add(Weight::from_ref_time(26_377_453 as u64).saturating_mul(r as u64)) + // Minimum execution time: 148_269 nanoseconds. + Weight::from_ref_time(152_128_988 as u64) + // Standard Error: 16_981 + .saturating_add(Weight::from_ref_time(12_691_070 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - Weight::from_ref_time(247_795_000 as u64) - // Standard Error: 349_627 - .saturating_add(Weight::from_ref_time(411_421_066 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_194 nanoseconds. + Weight::from_ref_time(249_462_948 as u64) + // Standard Error: 420_603 + .saturating_add(Weight::from_ref_time(382_005_385 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -610,31 +647,34 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - Weight::from_ref_time(405_147_000 as u64) - // Standard Error: 1_074_466 - .saturating_add(Weight::from_ref_time(120_331_835 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(8 as u64)) - .saturating_add(T::DbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(T::DbWeight::get().writes(6 as u64)) - .saturating_add(T::DbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 416_372 nanoseconds. + Weight::from_ref_time(558_600_043 as u64) + // Standard Error: 1_283_845 + .saturating_add(Weight::from_ref_time(87_356_639 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(52 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(50 as u64)) + .saturating_add(T::DbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - Weight::from_ref_time(403_403_000 as u64) - // Standard Error: 890_083 - .saturating_add(Weight::from_ref_time(88_023_518 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(8 as u64)) - .saturating_add(T::DbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(T::DbWeight::get().writes(6 as u64)) - .saturating_add(T::DbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 414_605 nanoseconds. + Weight::from_ref_time(531_590_681 as u64) + // Standard Error: 1_081_636 + .saturating_add(Weight::from_ref_time(61_988_451 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(51 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(49 as u64)) + .saturating_add(T::DbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - Weight::from_ref_time(247_929_000 as u64) - // Standard Error: 311_780 - .saturating_add(Weight::from_ref_time(400_904_526 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_561 nanoseconds. + Weight::from_ref_time(247_133_699 as u64) + // Standard Error: 430_882 + .saturating_add(Weight::from_ref_time(380_288_678 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -643,20 +683,22 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(372_378_000 as u64) - // Standard Error: 1_007_061 - .saturating_add(Weight::from_ref_time(92_326_546 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(7 as u64)) - .saturating_add(T::DbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(T::DbWeight::get().writes(4 as u64)) - .saturating_add(T::DbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 385_375 nanoseconds. + Weight::from_ref_time(515_998_814 as u64) + // Standard Error: 1_205_946 + .saturating_add(Weight::from_ref_time(63_741_054 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(51 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(48 as u64)) + .saturating_add(T::DbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - Weight::from_ref_time(250_165_000 as u64) - // Standard Error: 300_205 - .saturating_add(Weight::from_ref_time(339_092_950 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_047 nanoseconds. + Weight::from_ref_time(258_952_780 as u64) + // Standard Error: 359_810 + .saturating_add(Weight::from_ref_time(299_965_622 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -664,19 +706,21 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(352_873_000 as u64) - // Standard Error: 908_425 - .saturating_add(Weight::from_ref_time(176_951_688 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(8 as u64)) - .saturating_add(T::DbWeight::get().reads((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 364_719 nanoseconds. + Weight::from_ref_time(479_168_397 as u64) + // Standard Error: 1_056_296 + .saturating_add(Weight::from_ref_time(148_008_433 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(51 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - Weight::from_ref_time(248_980_000 as u64) - // Standard Error: 295_923 - .saturating_add(Weight::from_ref_time(306_145_709 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_860 nanoseconds. + Weight::from_ref_time(260_444_355 as u64) + // Standard Error: 354_017 + .saturating_add(Weight::from_ref_time(285_201_666 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -684,19 +728,21 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(340_418_000 as u64) - // Standard Error: 749_537 - .saturating_add(Weight::from_ref_time(80_040_174 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(7 as u64)) - .saturating_add(T::DbWeight::get().reads((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 359_457 nanoseconds. + Weight::from_ref_time(459_211_204 as u64) + // Standard Error: 912_412 + .saturating_add(Weight::from_ref_time(56_532_346 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(51 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - Weight::from_ref_time(250_254_000 as u64) - // Standard Error: 328_900 - .saturating_add(Weight::from_ref_time(424_144_552 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_064 nanoseconds. + Weight::from_ref_time(246_043_797 as u64) + // Standard Error: 442_983 + .saturating_add(Weight::from_ref_time(392_246_113 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -705,13 +751,14 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(377_849_000 as u64) - // Standard Error: 1_130_582 - .saturating_add(Weight::from_ref_time(188_240_273 as u64).saturating_mul(n as u64)) - .saturating_add(T::DbWeight::get().reads(8 as u64)) - .saturating_add(T::DbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(T::DbWeight::get().writes(5 as u64)) - .saturating_add(T::DbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 387_629 nanoseconds. + Weight::from_ref_time(529_491_574 as u64) + // Standard Error: 1_311_955 + .saturating_add(Weight::from_ref_time(155_160_167 as u64).saturating_mul(n as u64)) + .saturating_add(T::DbWeight::get().reads(51 as u64)) + .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(T::DbWeight::get().writes(48 as u64)) + .saturating_add(T::DbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) @@ -720,12 +767,13 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - Weight::from_ref_time(249_701_000 as u64) - // Standard Error: 449_896 - .saturating_add(Weight::from_ref_time(1_370_712_846 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 287_827 nanoseconds. + Weight::from_ref_time(226_727_998 as u64) + // Standard Error: 758_553 + .saturating_add(Weight::from_ref_time(1_311_899_729 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) - .saturating_add(T::DbWeight::get().writes(3 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) .saturating_add(T::DbWeight::get().writes((80 as u64).saturating_mul(r as u64))) } // Storage: System Account (r:1 w:0) @@ -735,10 +783,11 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - Weight::from_ref_time(251_015_000 as u64) - // Standard Error: 7_081_378 - .saturating_add(Weight::from_ref_time(17_258_935_295 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 286_474 nanoseconds. + Weight::from_ref_time(290_308_000 as u64) + // Standard Error: 6_440_996 + .saturating_add(Weight::from_ref_time(20_239_024_486 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) .saturating_add(T::DbWeight::get().writes((160 as u64).saturating_mul(r as u64))) @@ -750,9 +799,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - Weight::from_ref_time(250_660_000 as u64) - // Standard Error: 6_402_989 - .saturating_add(Weight::from_ref_time(17_044_780_887 as u64).saturating_mul(r as u64)) + // Minimum execution time: 288_054 nanoseconds. + Weight::from_ref_time(290_468_000 as u64) + // Standard Error: 6_594_354 + .saturating_add(Weight::from_ref_time(20_004_202_621 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -766,11 +816,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - Weight::from_ref_time(11_920_718_000 as u64) - // Standard Error: 11_123_062 - .saturating_add(Weight::from_ref_time(642_326_761 as u64).saturating_mul(t as u64)) - // Standard Error: 9_490 - .saturating_add(Weight::from_ref_time(8_845_752 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_023_111 nanoseconds. + Weight::from_ref_time(8_008_697_453 as u64) + // Standard Error: 6_164_150 + .saturating_add(Weight::from_ref_time(1_242_557_423 as u64).saturating_mul(t as u64)) + // Standard Error: 9_242 + .saturating_add(Weight::from_ref_time(9_790_280 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(167 as u64)) .saturating_add(T::DbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(163 as u64)) @@ -785,12 +836,13 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - Weight::from_ref_time(253_804_000 as u64) - // Standard Error: 19_742_198 - .saturating_add(Weight::from_ref_time(22_250_412_835 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) + // Minimum execution time: 286_837 nanoseconds. + Weight::from_ref_time(291_218_000 as u64) + // Standard Error: 19_786_457 + .saturating_add(Weight::from_ref_time(25_510_029_458 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((400 as u64).saturating_mul(r as u64))) - .saturating_add(T::DbWeight::get().writes(3 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) .saturating_add(T::DbWeight::get().writes((400 as u64).saturating_mul(r as u64))) } // Storage: System Account (r:81 w:81) @@ -803,9 +855,10 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - Weight::from_ref_time(13_921_591_000 as u64) - // Standard Error: 22_601 - .saturating_add(Weight::from_ref_time(125_945_348 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_068_335 nanoseconds. + Weight::from_ref_time(10_796_296_013 as u64) + // Standard Error: 76_863 + .saturating_add(Weight::from_ref_time(119_227_442 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(249 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(247 as u64)) @@ -818,9 +871,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - Weight::from_ref_time(247_842_000 as u64) - // Standard Error: 219_853 - .saturating_add(Weight::from_ref_time(58_013_100 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_120 nanoseconds. + Weight::from_ref_time(289_308_957 as u64) + // Standard Error: 166_497 + .saturating_add(Weight::from_ref_time(41_451_242 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -831,9 +885,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(305_607_000 as u64) - // Standard Error: 71_234 - .saturating_add(Weight::from_ref_time(323_093_184 as u64).saturating_mul(n as u64)) + // Minimum execution time: 329_812 nanoseconds. + Weight::from_ref_time(330_612_000 as u64) + // Standard Error: 53_026 + .saturating_add(Weight::from_ref_time(322_254_314 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -844,9 +899,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - Weight::from_ref_time(247_351_000 as u64) - // Standard Error: 271_656 - .saturating_add(Weight::from_ref_time(74_344_000 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_513 nanoseconds. + Weight::from_ref_time(288_770_253 as u64) + // Standard Error: 127_481 + .saturating_add(Weight::from_ref_time(54_024_646 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -857,9 +913,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(315_626_000 as u64) - // Standard Error: 56_955 - .saturating_add(Weight::from_ref_time(246_316_261 as u64).saturating_mul(n as u64)) + // Minimum execution time: 337_526 nanoseconds. + Weight::from_ref_time(341_798_000 as u64) + // Standard Error: 55_732 + .saturating_add(Weight::from_ref_time(246_278_245 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -870,9 +927,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - Weight::from_ref_time(246_887_000 as u64) - // Standard Error: 286_822 - .saturating_add(Weight::from_ref_time(52_242_599 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_755 nanoseconds. + Weight::from_ref_time(288_770_457 as u64) + // Standard Error: 126_198 + .saturating_add(Weight::from_ref_time(31_005_842 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -883,9 +941,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(294_818_000 as u64) - // Standard Error: 52_394 - .saturating_add(Weight::from_ref_time(96_353_967 as u64).saturating_mul(n as u64)) + // Minimum execution time: 318_456 nanoseconds. + Weight::from_ref_time(319_657_000 as u64) + // Standard Error: 48_627 + .saturating_add(Weight::from_ref_time(96_235_891 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -896,9 +955,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - Weight::from_ref_time(245_334_000 as u64) - // Standard Error: 303_979 - .saturating_add(Weight::from_ref_time(50_180_800 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_514 nanoseconds. + Weight::from_ref_time(286_965_600 as u64) + // Standard Error: 139_737 + .saturating_add(Weight::from_ref_time(31_455_000 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -909,9 +969,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(288_995_000 as u64) - // Standard Error: 51_161 - .saturating_add(Weight::from_ref_time(96_331_905 as u64).saturating_mul(n as u64)) + // Minimum execution time: 314_440 nanoseconds. + Weight::from_ref_time(317_795_000 as u64) + // Standard Error: 50_822 + .saturating_add(Weight::from_ref_time(96_256_697 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -922,9 +983,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - Weight::from_ref_time(249_935_000 as u64) - // Standard Error: 662_188 - .saturating_add(Weight::from_ref_time(3_025_889_600 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_599 nanoseconds. + Weight::from_ref_time(289_683_557 as u64) + // Standard Error: 536_607 + .saturating_add(Weight::from_ref_time(3_008_499_142 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -935,9 +997,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - Weight::from_ref_time(248_094_000 as u64) - // Standard Error: 535_446 - .saturating_add(Weight::from_ref_time(2_086_979_500 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_690 nanoseconds. + Weight::from_ref_time(289_027_440 as u64) + // Standard Error: 371_475 + .saturating_add(Weight::from_ref_time(2_049_105_659 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -949,319 +1012,371 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. fn seal_set_code_hash(r: u32, ) -> Weight { - Weight::from_ref_time(248_254_000 as u64) - // Standard Error: 1_340_955 - .saturating_add(Weight::from_ref_time(1_065_939_603 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_919 nanoseconds. + Weight::from_ref_time(288_356_000 as u64) + // Standard Error: 2_749_310 + .saturating_add(Weight::from_ref_time(1_358_240_619 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) - .saturating_add(T::DbWeight::get().reads((150 as u64).saturating_mul(r as u64))) + .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) .saturating_add(T::DbWeight::get().writes((150 as u64).saturating_mul(r as u64))) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - Weight::from_ref_time(70_705_000 as u64) - // Standard Error: 7_175 - .saturating_add(Weight::from_ref_time(983_586 as u64).saturating_mul(r as u64)) + // Minimum execution time: 633 nanoseconds. + Weight::from_ref_time(833_605 as u64) + // Standard Error: 256 + .saturating_add(Weight::from_ref_time(493_683 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - Weight::from_ref_time(69_659_000 as u64) - // Standard Error: 1_140 - .saturating_add(Weight::from_ref_time(3_004_307 as u64).saturating_mul(r as u64)) + // Minimum execution time: 772 nanoseconds. + Weight::from_ref_time(1_216_335 as u64) + // Standard Error: 506 + .saturating_add(Weight::from_ref_time(1_100_153 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - Weight::from_ref_time(69_621_000 as u64) - // Standard Error: 2_871 - .saturating_add(Weight::from_ref_time(2_715_451 as u64).saturating_mul(r as u64)) + // Minimum execution time: 752 nanoseconds. + Weight::from_ref_time(1_232_818 as u64) + // Standard Error: 509 + .saturating_add(Weight::from_ref_time(1_006_310 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - Weight::from_ref_time(69_459_000 as u64) - // Standard Error: 3_284 - .saturating_add(Weight::from_ref_time(2_581_283 as u64).saturating_mul(r as u64)) + // Minimum execution time: 636 nanoseconds. + Weight::from_ref_time(908_576 as u64) + // Standard Error: 223 + .saturating_add(Weight::from_ref_time(1_183_249 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - Weight::from_ref_time(69_558_000 as u64) - // Standard Error: 2_509 - .saturating_add(Weight::from_ref_time(2_906_689 as u64).saturating_mul(r as u64)) + // Minimum execution time: 654 nanoseconds. + Weight::from_ref_time(668_211 as u64) + // Standard Error: 1_202 + .saturating_add(Weight::from_ref_time(1_518_771 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - Weight::from_ref_time(69_407_000 as u64) - // Standard Error: 1_697 - .saturating_add(Weight::from_ref_time(1_702_534 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(859_213 as u64) + // Standard Error: 243 + .saturating_add(Weight::from_ref_time(669_217 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - Weight::from_ref_time(69_477_000 as u64) - // Standard Error: 1_733 - .saturating_add(Weight::from_ref_time(2_192_641 as u64).saturating_mul(r as u64)) + // Minimum execution time: 669 nanoseconds. + Weight::from_ref_time(811_434 as u64) + // Standard Error: 811 + .saturating_add(Weight::from_ref_time(932_974 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - Weight::from_ref_time(69_424_000 as u64) - // Standard Error: 2_096 - .saturating_add(Weight::from_ref_time(2_435_708 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(510_094 as u64) + // Standard Error: 1_793 + .saturating_add(Weight::from_ref_time(1_255_401 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - Weight::from_ref_time(72_883_000 as u64) - // Standard Error: 209 - .saturating_add(Weight::from_ref_time(6_874 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_454 nanoseconds. + Weight::from_ref_time(2_721_478 as u64) + // Standard Error: 52 + .saturating_add(Weight::from_ref_time(3_520 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - Weight::from_ref_time(69_422_000 as u64) - // Standard Error: 5_030 - .saturating_add(Weight::from_ref_time(7_638_087 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(1_524_706 as u64) + // Standard Error: 4_023 + .saturating_add(Weight::from_ref_time(2_429_512 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - Weight::from_ref_time(83_136_000 as u64) - // Standard Error: 7_751 - .saturating_add(Weight::from_ref_time(9_543_944 as u64).saturating_mul(r as u64)) + // Minimum execution time: 711 nanoseconds. + Weight::from_ref_time(1_576_545 as u64) + // Standard Error: 2_825 + .saturating_add(Weight::from_ref_time(3_063_132 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - Weight::from_ref_time(93_281_000 as u64) - // Standard Error: 1_967 - .saturating_add(Weight::from_ref_time(596_591 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_577 nanoseconds. + Weight::from_ref_time(5_305_612 as u64) + // Standard Error: 218 + .saturating_add(Weight::from_ref_time(207_324 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - Weight::from_ref_time(69_702_000 as u64) - // Standard Error: 1_112 - .saturating_add(Weight::from_ref_time(1_094_685 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_450 nanoseconds. + Weight::from_ref_time(1_746_256 as u64) + // Standard Error: 337 + .saturating_add(Weight::from_ref_time(609_345 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - Weight::from_ref_time(69_720_000 as u64) - // Standard Error: 1_768 - .saturating_add(Weight::from_ref_time(1_045_163 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_457 nanoseconds. + Weight::from_ref_time(1_699_261 as u64) + // Standard Error: 212 + .saturating_add(Weight::from_ref_time(512_774 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - Weight::from_ref_time(69_716_000 as u64) - // Standard Error: 1_000 - .saturating_add(Weight::from_ref_time(1_541_622 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_449 nanoseconds. + Weight::from_ref_time(1_726_109 as u64) + // Standard Error: 540 + .saturating_add(Weight::from_ref_time(722_939 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - Weight::from_ref_time(72_315_000 as u64) - // Standard Error: 1_081 - .saturating_add(Weight::from_ref_time(1_646_437 as u64).saturating_mul(r as u64)) + // Minimum execution time: 707 nanoseconds. + Weight::from_ref_time(1_012_945 as u64) + // Standard Error: 456 + .saturating_add(Weight::from_ref_time(978_825 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - Weight::from_ref_time(72_256_000 as u64) - // Standard Error: 1_749 - .saturating_add(Weight::from_ref_time(1_664_891 as u64).saturating_mul(r as u64)) + // Minimum execution time: 718 nanoseconds. + Weight::from_ref_time(991_713 as u64) + // Standard Error: 376 + .saturating_add(Weight::from_ref_time(958_921 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - Weight::from_ref_time(69_616_000 as u64) - // Standard Error: 1_303 - .saturating_add(Weight::from_ref_time(1_017_254 as u64).saturating_mul(r as u64)) + // Minimum execution time: 737 nanoseconds. + Weight::from_ref_time(1_003_536 as u64) + // Standard Error: 357 + .saturating_add(Weight::from_ref_time(753_905 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - Weight::from_ref_time(70_943_000 as u64) - // Standard Error: 120_139 - .saturating_add(Weight::from_ref_time(183_262_000 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(720_128 as u64) + // Standard Error: 3_756 + .saturating_add(Weight::from_ref_time(188_693_871 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - Weight::from_ref_time(70_953_000 as u64) - // Standard Error: 2_591 - .saturating_add(Weight::from_ref_time(1_458_584 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(892_350 as u64) + // Standard Error: 221 + .saturating_add(Weight::from_ref_time(672_006 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - Weight::from_ref_time(69_439_000 as u64) - // Standard Error: 1_822 - .saturating_add(Weight::from_ref_time(1_486_431 as u64).saturating_mul(r as u64)) + // Minimum execution time: 652 nanoseconds. + Weight::from_ref_time(921_248 as u64) + // Standard Error: 298 + .saturating_add(Weight::from_ref_time(671_631 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - Weight::from_ref_time(69_366_000 as u64) - // Standard Error: 2_674 - .saturating_add(Weight::from_ref_time(1_506_755 as u64).saturating_mul(r as u64)) + // Minimum execution time: 645 nanoseconds. + Weight::from_ref_time(890_444 as u64) + // Standard Error: 247 + .saturating_add(Weight::from_ref_time(672_057 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - Weight::from_ref_time(69_386_000 as u64) - // Standard Error: 3_040 - .saturating_add(Weight::from_ref_time(1_509_928 as u64).saturating_mul(r as u64)) + // Minimum execution time: 684 nanoseconds. + Weight::from_ref_time(910_228 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(684_713 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - Weight::from_ref_time(69_432_000 as u64) - // Standard Error: 1_875 - .saturating_add(Weight::from_ref_time(1_439_336 as u64).saturating_mul(r as u64)) + // Minimum execution time: 668 nanoseconds. + Weight::from_ref_time(874_456 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(671_242 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - Weight::from_ref_time(69_488_000 as u64) - // Standard Error: 1_654 - .saturating_add(Weight::from_ref_time(1_429_318 as u64).saturating_mul(r as u64)) + // Minimum execution time: 632 nanoseconds. + Weight::from_ref_time(900_807 as u64) + // Standard Error: 235 + .saturating_add(Weight::from_ref_time(670_298 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - Weight::from_ref_time(69_414_000 as u64) - // Standard Error: 2_773 - .saturating_add(Weight::from_ref_time(1_499_116 as u64).saturating_mul(r as u64)) + // Minimum execution time: 647 nanoseconds. + Weight::from_ref_time(910_984 as u64) + // Standard Error: 327 + .saturating_add(Weight::from_ref_time(671_129 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - Weight::from_ref_time(69_427_000 as u64) - // Standard Error: 2_404 - .saturating_add(Weight::from_ref_time(1_969_697 as u64).saturating_mul(r as u64)) + // Minimum execution time: 658 nanoseconds. + Weight::from_ref_time(895_986 as u64) + // Standard Error: 565 + .saturating_add(Weight::from_ref_time(913_649 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - Weight::from_ref_time(70_793_000 as u64) - // Standard Error: 1_765 - .saturating_add(Weight::from_ref_time(1_924_169 as u64).saturating_mul(r as u64)) + // Minimum execution time: 671 nanoseconds. + Weight::from_ref_time(892_539 as u64) + // Standard Error: 202 + .saturating_add(Weight::from_ref_time(913_503 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - Weight::from_ref_time(69_551_000 as u64) - // Standard Error: 3_955 - .saturating_add(Weight::from_ref_time(1_988_825 as u64).saturating_mul(r as u64)) + // Minimum execution time: 655 nanoseconds. + Weight::from_ref_time(960_186 as u64) + // Standard Error: 472 + .saturating_add(Weight::from_ref_time(922_417 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - Weight::from_ref_time(69_510_000 as u64) - // Standard Error: 3_797 - .saturating_add(Weight::from_ref_time(1_976_317 as u64).saturating_mul(r as u64)) + // Minimum execution time: 635 nanoseconds. + Weight::from_ref_time(870_482 as u64) + // Standard Error: 274 + .saturating_add(Weight::from_ref_time(914_130 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - Weight::from_ref_time(69_399_000 as u64) - // Standard Error: 3_255 - .saturating_add(Weight::from_ref_time(1_975_054 as u64).saturating_mul(r as u64)) + // Minimum execution time: 621 nanoseconds. + Weight::from_ref_time(891_451 as u64) + // Standard Error: 247 + .saturating_add(Weight::from_ref_time(909_133 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - Weight::from_ref_time(69_425_000 as u64) - // Standard Error: 1_738 - .saturating_add(Weight::from_ref_time(1_959_864 as u64).saturating_mul(r as u64)) + // Minimum execution time: 662 nanoseconds. + Weight::from_ref_time(904_400 as u64) + // Standard Error: 194 + .saturating_add(Weight::from_ref_time(917_254 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - Weight::from_ref_time(69_514_000 as u64) - // Standard Error: 9_227 - .saturating_add(Weight::from_ref_time(1_984_750 as u64).saturating_mul(r as u64)) + // Minimum execution time: 673 nanoseconds. + Weight::from_ref_time(913_787 as u64) + // Standard Error: 185 + .saturating_add(Weight::from_ref_time(911_025 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - Weight::from_ref_time(69_415_000 as u64) - // Standard Error: 2_052 - .saturating_add(Weight::from_ref_time(1_967_146 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(892_985 as u64) + // Standard Error: 175 + .saturating_add(Weight::from_ref_time(919_451 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - Weight::from_ref_time(69_348_000 as u64) - // Standard Error: 3_647 - .saturating_add(Weight::from_ref_time(1_996_141 as u64).saturating_mul(r as u64)) + // Minimum execution time: 666 nanoseconds. + Weight::from_ref_time(907_510 as u64) + // Standard Error: 204 + .saturating_add(Weight::from_ref_time(911_125 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - Weight::from_ref_time(69_448_000 as u64) - // Standard Error: 1_960 - .saturating_add(Weight::from_ref_time(1_956_889 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(896_012 as u64) + // Standard Error: 262 + .saturating_add(Weight::from_ref_time(911_762 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - Weight::from_ref_time(69_443_000 as u64) - // Standard Error: 20_301 - .saturating_add(Weight::from_ref_time(2_072_285 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(921_793 as u64) + // Standard Error: 220 + .saturating_add(Weight::from_ref_time(900_803 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - Weight::from_ref_time(69_458_000 as u64) - // Standard Error: 3_210 - .saturating_add(Weight::from_ref_time(1_970_367 as u64).saturating_mul(r as u64)) + // Minimum execution time: 676 nanoseconds. + Weight::from_ref_time(908_870 as u64) + // Standard Error: 277 + .saturating_add(Weight::from_ref_time(897_408 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - Weight::from_ref_time(69_429_000 as u64) - // Standard Error: 3_475 - .saturating_add(Weight::from_ref_time(1_977_800 as u64).saturating_mul(r as u64)) + // Minimum execution time: 671 nanoseconds. + Weight::from_ref_time(806_379 as u64) + // Standard Error: 638 + .saturating_add(Weight::from_ref_time(911_294 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - Weight::from_ref_time(69_414_000 as u64) - // Standard Error: 2_659 - .saturating_add(Weight::from_ref_time(2_797_503 as u64).saturating_mul(r as u64)) + // Minimum execution time: 639 nanoseconds. + Weight::from_ref_time(679_032 as u64) + // Standard Error: 6_536 + .saturating_add(Weight::from_ref_time(1_512_247 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - Weight::from_ref_time(69_460_000 as u64) - // Standard Error: 2_399 - .saturating_add(Weight::from_ref_time(2_646_574 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(864_336 as u64) + // Standard Error: 251 + .saturating_add(Weight::from_ref_time(1_361_436 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - Weight::from_ref_time(69_441_000 as u64) - // Standard Error: 2_179 - .saturating_add(Weight::from_ref_time(2_860_283 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(969_193 as u64) + // Standard Error: 333 + .saturating_add(Weight::from_ref_time(1_521_975 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - Weight::from_ref_time(69_401_000 as u64) - // Standard Error: 2_639 - .saturating_add(Weight::from_ref_time(2_582_137 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(869_301 as u64) + // Standard Error: 177 + .saturating_add(Weight::from_ref_time(1_361_528 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - Weight::from_ref_time(69_426_000 as u64) - // Standard Error: 2_379 - .saturating_add(Weight::from_ref_time(1_986_578 as u64).saturating_mul(r as u64)) + // Minimum execution time: 626 nanoseconds. + Weight::from_ref_time(883_738 as u64) + // Standard Error: 288 + .saturating_add(Weight::from_ref_time(901_730 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - Weight::from_ref_time(69_599_000 as u64) - // Standard Error: 2_918 - .saturating_add(Weight::from_ref_time(1_991_834 as u64).saturating_mul(r as u64)) + // Minimum execution time: 637 nanoseconds. + Weight::from_ref_time(892_052 as u64) + // Standard Error: 297 + .saturating_add(Weight::from_ref_time(901_479 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - Weight::from_ref_time(71_142_000 as u64) - // Standard Error: 2_659 - .saturating_add(Weight::from_ref_time(1_948_956 as u64).saturating_mul(r as u64)) + // Minimum execution time: 617 nanoseconds. + Weight::from_ref_time(882_714 as u64) + // Standard Error: 207 + .saturating_add(Weight::from_ref_time(901_984 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - Weight::from_ref_time(69_407_000 as u64) - // Standard Error: 4_100 - .saturating_add(Weight::from_ref_time(2_030_715 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(885_605 as u64) + // Standard Error: 329 + .saturating_add(Weight::from_ref_time(911_644 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - Weight::from_ref_time(69_534_000 as u64) - // Standard Error: 2_305 - .saturating_add(Weight::from_ref_time(1_989_346 as u64).saturating_mul(r as u64)) + // Minimum execution time: 655 nanoseconds. + Weight::from_ref_time(916_923 as u64) + // Standard Error: 219 + .saturating_add(Weight::from_ref_time(910_766 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - Weight::from_ref_time(69_432_000 as u64) - // Standard Error: 2_747 - .saturating_add(Weight::from_ref_time(2_002_548 as u64).saturating_mul(r as u64)) + // Minimum execution time: 688 nanoseconds. + Weight::from_ref_time(890_697 as u64) + // Standard Error: 224 + .saturating_add(Weight::from_ref_time(910_605 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - Weight::from_ref_time(69_465_000 as u64) - // Standard Error: 9_644 - .saturating_add(Weight::from_ref_time(2_045_830 as u64).saturating_mul(r as u64)) + // Minimum execution time: 679 nanoseconds. + Weight::from_ref_time(964_104 as u64) + // Standard Error: 658 + .saturating_add(Weight::from_ref_time(908_547 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - Weight::from_ref_time(69_435_000 as u64) - // Standard Error: 2_271 - .saturating_add(Weight::from_ref_time(2_001_986 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(879_488 as u64) + // Standard Error: 195 + .saturating_add(Weight::from_ref_time(910_911 as u64).saturating_mul(r as u64)) } } @@ -1269,15 +1384,17 @@ impl WeightInfo for SubstrateWeight { impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - Weight::from_ref_time(3_108_000 as u64) + // Minimum execution time: 2_919 nanoseconds. + Weight::from_ref_time(3_033_000 as u64) .saturating_add(RocksDbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - Weight::from_ref_time(15_377_000 as u64) - // Standard Error: 414 - .saturating_add(Weight::from_ref_time(892_761 as u64).saturating_mul(k as u64)) + // Minimum execution time: 14_627 nanoseconds. + Weight::from_ref_time(16_018_897 as u64) + // Standard Error: 824 + .saturating_add(Weight::from_ref_time(893_332 as u64).saturating_mul(k as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) .saturating_add(RocksDbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -1285,18 +1402,21 @@ impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - Weight::from_ref_time(3_127_000 as u64) - // Standard Error: 3_813 - .saturating_add(Weight::from_ref_time(1_379_402 as u64).saturating_mul(q as u64)) + // Minimum execution time: 2_867 nanoseconds. + Weight::from_ref_time(13_411_793 as u64) + // Standard Error: 5_268 + .saturating_add(Weight::from_ref_time(1_244_288 as u64).saturating_mul(q as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) } // Storage: Contracts PristineCode (r:1 w:0) // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - Weight::from_ref_time(22_849_000 as u64) - // Standard Error: 26 - .saturating_add(Weight::from_ref_time(45_513 as u64).saturating_mul(c as u64)) + // Minimum execution time: 20_987 nanoseconds. + Weight::from_ref_time(24_245_898 as u64) + // Standard Error: 48 + .saturating_add(Weight::from_ref_time(34_792 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1307,9 +1427,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - Weight::from_ref_time(258_275_000 as u64) - // Standard Error: 30 - .saturating_add(Weight::from_ref_time(45_885 as u64).saturating_mul(c as u64)) + // Minimum execution time: 299_074 nanoseconds. + Weight::from_ref_time(306_372_889 as u64) + // Standard Error: 25 + .saturating_add(Weight::from_ref_time(30_663 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1324,11 +1445,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - Weight::from_ref_time(2_115_889_000 as u64) - // Standard Error: 323 - .saturating_add(Weight::from_ref_time(89_541 as u64).saturating_mul(c as u64)) - // Standard Error: 19 - .saturating_add(Weight::from_ref_time(664 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_072_174 nanoseconds. + Weight::from_ref_time(337_874_723 as u64) + // Standard Error: 73 + .saturating_add(Weight::from_ref_time(88_343 as u64).saturating_mul(c as u64)) + // Standard Error: 4 + .saturating_add(Weight::from_ref_time(1_695 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(9 as u64)) } @@ -1341,9 +1463,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - Weight::from_ref_time(211_349_000 as u64) + // Minimum execution time: 178_787 nanoseconds. + Weight::from_ref_time(171_072_954 as u64) // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_532 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_447 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(7 as u64)) } @@ -1353,7 +1476,8 @@ impl WeightInfo for () { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - Weight::from_ref_time(181_771_000 as u64) + // Minimum execution time: 147_880 nanoseconds. + Weight::from_ref_time(149_054_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1363,9 +1487,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - Weight::from_ref_time(55_917_000 as u64) - // Standard Error: 25 - .saturating_add(Weight::from_ref_time(46_148 as u64).saturating_mul(c as u64)) + // Minimum execution time: 281_951 nanoseconds. + Weight::from_ref_time(296_591_045 as u64) + // Standard Error: 59 + .saturating_add(Weight::from_ref_time(75_741 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1374,7 +1499,8 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - Weight::from_ref_time(37_966_000 as u64) + // Minimum execution time: 38_314 nanoseconds. + Weight::from_ref_time(39_208_000 as u64) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1382,7 +1508,8 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - Weight::from_ref_time(40_963_000 as u64) + // Minimum execution time: 40_821 nanoseconds. + Weight::from_ref_time(41_085_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(6 as u64)) } @@ -1393,9 +1520,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - Weight::from_ref_time(247_526_000 as u64) - // Standard Error: 29_505 - .saturating_add(Weight::from_ref_time(35_107_467 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_566 nanoseconds. + Weight::from_ref_time(291_662_997 as u64) + // Standard Error: 26_198 + .saturating_add(Weight::from_ref_time(15_812_705 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1406,9 +1534,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - Weight::from_ref_time(253_782_000 as u64) - // Standard Error: 256_004 - .saturating_add(Weight::from_ref_time(201_621_188 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_050 nanoseconds. + Weight::from_ref_time(231_589_172 as u64) + // Standard Error: 457_107 + .saturating_add(Weight::from_ref_time(194_493_604 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1420,9 +1549,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - Weight::from_ref_time(249_892_000 as u64) - // Standard Error: 234_750 - .saturating_add(Weight::from_ref_time(258_209_168 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_561 nanoseconds. + Weight::from_ref_time(241_544_282 as u64) + // Standard Error: 439_485 + .saturating_add(Weight::from_ref_time(234_068_306 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1434,9 +1564,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - Weight::from_ref_time(248_674_000 as u64) - // Standard Error: 23_962 - .saturating_add(Weight::from_ref_time(38_319_695 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_800 nanoseconds. + Weight::from_ref_time(292_300_021 as u64) + // Standard Error: 40_833 + .saturating_add(Weight::from_ref_time(19_473_073 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1447,9 +1578,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - Weight::from_ref_time(244_345_000 as u64) - // Standard Error: 15_429 - .saturating_add(Weight::from_ref_time(14_751_125 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_811 nanoseconds. + Weight::from_ref_time(289_605_062 as u64) + // Standard Error: 17_481 + .saturating_add(Weight::from_ref_time(11_088_146 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1460,9 +1592,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - Weight::from_ref_time(247_045_000 as u64) - // Standard Error: 25_949 - .saturating_add(Weight::from_ref_time(35_001_004 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_389 nanoseconds. + Weight::from_ref_time(291_607_958 as u64) + // Standard Error: 33_895 + .saturating_add(Weight::from_ref_time(15_781_940 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1473,9 +1606,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - Weight::from_ref_time(247_176_000 as u64) - // Standard Error: 24_500 - .saturating_add(Weight::from_ref_time(34_447_506 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_896 nanoseconds. + Weight::from_ref_time(289_802_376 as u64) + // Standard Error: 33_013 + .saturating_add(Weight::from_ref_time(15_705_525 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1486,10 +1620,11 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - Weight::from_ref_time(247_278_000 as u64) - // Standard Error: 48_613 - .saturating_add(Weight::from_ref_time(108_381_432 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) + // Minimum execution time: 284_380 nanoseconds. + Weight::from_ref_time(291_136_750 as u64) + // Standard Error: 92_026 + .saturating_add(Weight::from_ref_time(86_938_178 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) @@ -1499,9 +1634,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - Weight::from_ref_time(246_996_000 as u64) - // Standard Error: 24_585 - .saturating_add(Weight::from_ref_time(34_615_777 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_734 nanoseconds. + Weight::from_ref_time(290_556_604 as u64) + // Standard Error: 31_726 + .saturating_add(Weight::from_ref_time(15_580_656 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1512,9 +1648,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - Weight::from_ref_time(247_207_000 as u64) - // Standard Error: 30_691 - .saturating_add(Weight::from_ref_time(34_626_552 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_935 nanoseconds. + Weight::from_ref_time(290_693_236 as u64) + // Standard Error: 24_862 + .saturating_add(Weight::from_ref_time(15_421_306 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1525,9 +1662,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - Weight::from_ref_time(247_538_000 as u64) - // Standard Error: 27_128 - .saturating_add(Weight::from_ref_time(34_277_292 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_010 nanoseconds. + Weight::from_ref_time(290_738_164 as u64) + // Standard Error: 20_205 + .saturating_add(Weight::from_ref_time(15_237_554 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1538,9 +1676,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - Weight::from_ref_time(247_398_000 as u64) - // Standard Error: 28_375 - .saturating_add(Weight::from_ref_time(34_573_437 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_862 nanoseconds. + Weight::from_ref_time(291_029_188 as u64) + // Standard Error: 30_491 + .saturating_add(Weight::from_ref_time(15_450_941 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1552,10 +1691,11 @@ impl WeightInfo for () { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - Weight::from_ref_time(247_732_000 as u64) - // Standard Error: 42_671 - .saturating_add(Weight::from_ref_time(123_110_886 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) + // Minimum execution time: 283_725 nanoseconds. + Weight::from_ref_time(293_071_360 as u64) + // Standard Error: 97_620 + .saturating_add(Weight::from_ref_time(85_454_560 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) @@ -1565,9 +1705,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - Weight::from_ref_time(170_547_000 as u64) - // Standard Error: 9_163 - .saturating_add(Weight::from_ref_time(15_589_088 as u64).saturating_mul(r as u64)) + // Minimum execution time: 135_545 nanoseconds. + Weight::from_ref_time(139_022_047 as u64) + // Standard Error: 9_547 + .saturating_add(Weight::from_ref_time(7_859_219 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1578,9 +1719,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - Weight::from_ref_time(247_264_000 as u64) - // Standard Error: 23_913 - .saturating_add(Weight::from_ref_time(32_753_431 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_396 nanoseconds. + Weight::from_ref_time(291_462_361 as u64) + // Standard Error: 28_397 + .saturating_add(Weight::from_ref_time(13_492_690 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1591,9 +1733,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(282_721_000 as u64) - // Standard Error: 1_978 - .saturating_add(Weight::from_ref_time(9_625_699 as u64).saturating_mul(n as u64)) + // Minimum execution time: 302_871 nanoseconds. + Weight::from_ref_time(320_897_273 as u64) + // Standard Error: 3_496 + .saturating_add(Weight::from_ref_time(9_614_024 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1604,9 +1747,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - Weight::from_ref_time(244_356_000 as u64) - // Standard Error: 184_002 - .saturating_add(Weight::from_ref_time(2_423_400 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_519 nanoseconds. + Weight::from_ref_time(286_177_785 as u64) + // Standard Error: 101_357 + .saturating_add(Weight::from_ref_time(888_714 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1617,9 +1761,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(246_157_000 as u64) - // Standard Error: 324 - .saturating_add(Weight::from_ref_time(188_687 as u64).saturating_mul(n as u64)) + // Minimum execution time: 285_901 nanoseconds. + Weight::from_ref_time(287_315_127 as u64) + // Standard Error: 877 + .saturating_add(Weight::from_ref_time(190_891 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1632,9 +1777,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - Weight::from_ref_time(247_356_000 as u64) - // Standard Error: 232_552 - .saturating_add(Weight::from_ref_time(55_027_099 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_147 nanoseconds. + Weight::from_ref_time(287_753_920 as u64) + // Standard Error: 99_065 + .saturating_add(Weight::from_ref_time(53_786_379 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1648,10 +1794,11 @@ impl WeightInfo for () { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - Weight::from_ref_time(247_069_000 as u64) - // Standard Error: 59_538 - .saturating_add(Weight::from_ref_time(128_858_347 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) + // Minimum execution time: 282_779 nanoseconds. + Weight::from_ref_time(295_701_851 as u64) + // Standard Error: 92_851 + .saturating_add(Weight::from_ref_time(106_176_241 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) @@ -1661,9 +1808,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - Weight::from_ref_time(244_659_000 as u64) - // Standard Error: 70_677 - .saturating_add(Weight::from_ref_time(239_930_533 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_392 nanoseconds. + Weight::from_ref_time(296_151_487 as u64) + // Standard Error: 117_012 + .saturating_add(Weight::from_ref_time(222_546_893 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1675,11 +1823,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - Weight::from_ref_time(1_198_350_000 as u64) - // Standard Error: 2_049_556 - .saturating_add(Weight::from_ref_time(70_072_141 as u64).saturating_mul(t as u64)) - // Standard Error: 496_378 - .saturating_add(Weight::from_ref_time(35_566_752 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_192_807 nanoseconds. + Weight::from_ref_time(506_881_525 as u64) + // Standard Error: 443_155 + .saturating_add(Weight::from_ref_time(177_724_866 as u64).saturating_mul(t as u64)) + // Standard Error: 121_711 + .saturating_add(Weight::from_ref_time(67_213_725 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1692,18 +1841,20 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - Weight::from_ref_time(177_240_000 as u64) - // Standard Error: 18_991 - .saturating_add(Weight::from_ref_time(26_377_453 as u64).saturating_mul(r as u64)) + // Minimum execution time: 148_269 nanoseconds. + Weight::from_ref_time(152_128_988 as u64) + // Standard Error: 16_981 + .saturating_add(Weight::from_ref_time(12_691_070 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - Weight::from_ref_time(247_795_000 as u64) - // Standard Error: 349_627 - .saturating_add(Weight::from_ref_time(411_421_066 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_194 nanoseconds. + Weight::from_ref_time(249_462_948 as u64) + // Standard Error: 420_603 + .saturating_add(Weight::from_ref_time(382_005_385 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1712,31 +1863,34 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - Weight::from_ref_time(405_147_000 as u64) - // Standard Error: 1_074_466 - .saturating_add(Weight::from_ref_time(120_331_835 as u64).saturating_mul(n as u64)) - .saturating_add(RocksDbWeight::get().reads(8 as u64)) - .saturating_add(RocksDbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(RocksDbWeight::get().writes(6 as u64)) - .saturating_add(RocksDbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 416_372 nanoseconds. + Weight::from_ref_time(558_600_043 as u64) + // Standard Error: 1_283_845 + .saturating_add(Weight::from_ref_time(87_356_639 as u64).saturating_mul(n as u64)) + .saturating_add(RocksDbWeight::get().reads(52 as u64)) + .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(RocksDbWeight::get().writes(50 as u64)) + .saturating_add(RocksDbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - Weight::from_ref_time(403_403_000 as u64) - // Standard Error: 890_083 - .saturating_add(Weight::from_ref_time(88_023_518 as u64).saturating_mul(n as u64)) - .saturating_add(RocksDbWeight::get().reads(8 as u64)) - .saturating_add(RocksDbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(RocksDbWeight::get().writes(6 as u64)) - .saturating_add(RocksDbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 414_605 nanoseconds. + Weight::from_ref_time(531_590_681 as u64) + // Standard Error: 1_081_636 + .saturating_add(Weight::from_ref_time(61_988_451 as u64).saturating_mul(n as u64)) + .saturating_add(RocksDbWeight::get().reads(51 as u64)) + .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(RocksDbWeight::get().writes(49 as u64)) + .saturating_add(RocksDbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - Weight::from_ref_time(247_929_000 as u64) - // Standard Error: 311_780 - .saturating_add(Weight::from_ref_time(400_904_526 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_561 nanoseconds. + Weight::from_ref_time(247_133_699 as u64) + // Standard Error: 430_882 + .saturating_add(Weight::from_ref_time(380_288_678 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1745,20 +1899,22 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(372_378_000 as u64) - // Standard Error: 1_007_061 - .saturating_add(Weight::from_ref_time(92_326_546 as u64).saturating_mul(n as u64)) - .saturating_add(RocksDbWeight::get().reads(7 as u64)) - .saturating_add(RocksDbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(RocksDbWeight::get().writes(4 as u64)) - .saturating_add(RocksDbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 385_375 nanoseconds. + Weight::from_ref_time(515_998_814 as u64) + // Standard Error: 1_205_946 + .saturating_add(Weight::from_ref_time(63_741_054 as u64).saturating_mul(n as u64)) + .saturating_add(RocksDbWeight::get().reads(51 as u64)) + .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(RocksDbWeight::get().writes(48 as u64)) + .saturating_add(RocksDbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - Weight::from_ref_time(250_165_000 as u64) - // Standard Error: 300_205 - .saturating_add(Weight::from_ref_time(339_092_950 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_047 nanoseconds. + Weight::from_ref_time(258_952_780 as u64) + // Standard Error: 359_810 + .saturating_add(Weight::from_ref_time(299_965_622 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1766,19 +1922,21 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(352_873_000 as u64) - // Standard Error: 908_425 - .saturating_add(Weight::from_ref_time(176_951_688 as u64).saturating_mul(n as u64)) - .saturating_add(RocksDbWeight::get().reads(8 as u64)) - .saturating_add(RocksDbWeight::get().reads((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 364_719 nanoseconds. + Weight::from_ref_time(479_168_397 as u64) + // Standard Error: 1_056_296 + .saturating_add(Weight::from_ref_time(148_008_433 as u64).saturating_mul(n as u64)) + .saturating_add(RocksDbWeight::get().reads(51 as u64)) + .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - Weight::from_ref_time(248_980_000 as u64) - // Standard Error: 295_923 - .saturating_add(Weight::from_ref_time(306_145_709 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_860 nanoseconds. + Weight::from_ref_time(260_444_355 as u64) + // Standard Error: 354_017 + .saturating_add(Weight::from_ref_time(285_201_666 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1786,19 +1944,21 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(340_418_000 as u64) - // Standard Error: 749_537 - .saturating_add(Weight::from_ref_time(80_040_174 as u64).saturating_mul(n as u64)) - .saturating_add(RocksDbWeight::get().reads(7 as u64)) - .saturating_add(RocksDbWeight::get().reads((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 359_457 nanoseconds. + Weight::from_ref_time(459_211_204 as u64) + // Standard Error: 912_412 + .saturating_add(Weight::from_ref_time(56_532_346 as u64).saturating_mul(n as u64)) + .saturating_add(RocksDbWeight::get().reads(51 as u64)) + .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - Weight::from_ref_time(250_254_000 as u64) - // Standard Error: 328_900 - .saturating_add(Weight::from_ref_time(424_144_552 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_064 nanoseconds. + Weight::from_ref_time(246_043_797 as u64) + // Standard Error: 442_983 + .saturating_add(Weight::from_ref_time(392_246_113 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1807,13 +1967,14 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(377_849_000 as u64) - // Standard Error: 1_130_582 - .saturating_add(Weight::from_ref_time(188_240_273 as u64).saturating_mul(n as u64)) - .saturating_add(RocksDbWeight::get().reads(8 as u64)) - .saturating_add(RocksDbWeight::get().reads((15 as u64).saturating_mul(n as u64))) - .saturating_add(RocksDbWeight::get().writes(5 as u64)) - .saturating_add(RocksDbWeight::get().writes((15 as u64).saturating_mul(n as u64))) + // Minimum execution time: 387_629 nanoseconds. + Weight::from_ref_time(529_491_574 as u64) + // Standard Error: 1_311_955 + .saturating_add(Weight::from_ref_time(155_160_167 as u64).saturating_mul(n as u64)) + .saturating_add(RocksDbWeight::get().reads(51 as u64)) + .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) + .saturating_add(RocksDbWeight::get().writes(48 as u64)) + .saturating_add(RocksDbWeight::get().writes((7 as u64).saturating_mul(n as u64))) } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) @@ -1822,12 +1983,13 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - Weight::from_ref_time(249_701_000 as u64) - // Standard Error: 449_896 - .saturating_add(Weight::from_ref_time(1_370_712_846 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) + // Minimum execution time: 287_827 nanoseconds. + Weight::from_ref_time(226_727_998 as u64) + // Standard Error: 758_553 + .saturating_add(Weight::from_ref_time(1_311_899_729 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) - .saturating_add(RocksDbWeight::get().writes(3 as u64)) + .saturating_add(RocksDbWeight::get().writes(4 as u64)) .saturating_add(RocksDbWeight::get().writes((80 as u64).saturating_mul(r as u64))) } // Storage: System Account (r:1 w:0) @@ -1837,10 +1999,11 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - Weight::from_ref_time(251_015_000 as u64) - // Standard Error: 7_081_378 - .saturating_add(Weight::from_ref_time(17_258_935_295 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) + // Minimum execution time: 286_474 nanoseconds. + Weight::from_ref_time(290_308_000 as u64) + // Standard Error: 6_440_996 + .saturating_add(Weight::from_ref_time(20_239_024_486 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) .saturating_add(RocksDbWeight::get().writes((160 as u64).saturating_mul(r as u64))) @@ -1852,9 +2015,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - Weight::from_ref_time(250_660_000 as u64) - // Standard Error: 6_402_989 - .saturating_add(Weight::from_ref_time(17_044_780_887 as u64).saturating_mul(r as u64)) + // Minimum execution time: 288_054 nanoseconds. + Weight::from_ref_time(290_468_000 as u64) + // Standard Error: 6_594_354 + .saturating_add(Weight::from_ref_time(20_004_202_621 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1868,11 +2032,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - Weight::from_ref_time(11_920_718_000 as u64) - // Standard Error: 11_123_062 - .saturating_add(Weight::from_ref_time(642_326_761 as u64).saturating_mul(t as u64)) - // Standard Error: 9_490 - .saturating_add(Weight::from_ref_time(8_845_752 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_023_111 nanoseconds. + Weight::from_ref_time(8_008_697_453 as u64) + // Standard Error: 6_164_150 + .saturating_add(Weight::from_ref_time(1_242_557_423 as u64).saturating_mul(t as u64)) + // Standard Error: 9_242 + .saturating_add(Weight::from_ref_time(9_790_280 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(167 as u64)) .saturating_add(RocksDbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(163 as u64)) @@ -1887,12 +2052,13 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - Weight::from_ref_time(253_804_000 as u64) - // Standard Error: 19_742_198 - .saturating_add(Weight::from_ref_time(22_250_412_835 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) + // Minimum execution time: 286_837 nanoseconds. + Weight::from_ref_time(291_218_000 as u64) + // Standard Error: 19_786_457 + .saturating_add(Weight::from_ref_time(25_510_029_458 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().reads((400 as u64).saturating_mul(r as u64))) - .saturating_add(RocksDbWeight::get().writes(3 as u64)) + .saturating_add(RocksDbWeight::get().writes(5 as u64)) .saturating_add(RocksDbWeight::get().writes((400 as u64).saturating_mul(r as u64))) } // Storage: System Account (r:81 w:81) @@ -1905,9 +2071,10 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - Weight::from_ref_time(13_921_591_000 as u64) - // Standard Error: 22_601 - .saturating_add(Weight::from_ref_time(125_945_348 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_068_335 nanoseconds. + Weight::from_ref_time(10_796_296_013 as u64) + // Standard Error: 76_863 + .saturating_add(Weight::from_ref_time(119_227_442 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(249 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(247 as u64)) @@ -1920,9 +2087,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - Weight::from_ref_time(247_842_000 as u64) - // Standard Error: 219_853 - .saturating_add(Weight::from_ref_time(58_013_100 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_120 nanoseconds. + Weight::from_ref_time(289_308_957 as u64) + // Standard Error: 166_497 + .saturating_add(Weight::from_ref_time(41_451_242 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1933,9 +2101,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(305_607_000 as u64) - // Standard Error: 71_234 - .saturating_add(Weight::from_ref_time(323_093_184 as u64).saturating_mul(n as u64)) + // Minimum execution time: 329_812 nanoseconds. + Weight::from_ref_time(330_612_000 as u64) + // Standard Error: 53_026 + .saturating_add(Weight::from_ref_time(322_254_314 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1946,9 +2115,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - Weight::from_ref_time(247_351_000 as u64) - // Standard Error: 271_656 - .saturating_add(Weight::from_ref_time(74_344_000 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_513 nanoseconds. + Weight::from_ref_time(288_770_253 as u64) + // Standard Error: 127_481 + .saturating_add(Weight::from_ref_time(54_024_646 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1959,9 +2129,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(315_626_000 as u64) - // Standard Error: 56_955 - .saturating_add(Weight::from_ref_time(246_316_261 as u64).saturating_mul(n as u64)) + // Minimum execution time: 337_526 nanoseconds. + Weight::from_ref_time(341_798_000 as u64) + // Standard Error: 55_732 + .saturating_add(Weight::from_ref_time(246_278_245 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1972,9 +2143,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - Weight::from_ref_time(246_887_000 as u64) - // Standard Error: 286_822 - .saturating_add(Weight::from_ref_time(52_242_599 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_755 nanoseconds. + Weight::from_ref_time(288_770_457 as u64) + // Standard Error: 126_198 + .saturating_add(Weight::from_ref_time(31_005_842 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1985,9 +2157,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(294_818_000 as u64) - // Standard Error: 52_394 - .saturating_add(Weight::from_ref_time(96_353_967 as u64).saturating_mul(n as u64)) + // Minimum execution time: 318_456 nanoseconds. + Weight::from_ref_time(319_657_000 as u64) + // Standard Error: 48_627 + .saturating_add(Weight::from_ref_time(96_235_891 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1998,9 +2171,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - Weight::from_ref_time(245_334_000 as u64) - // Standard Error: 303_979 - .saturating_add(Weight::from_ref_time(50_180_800 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_514 nanoseconds. + Weight::from_ref_time(286_965_600 as u64) + // Standard Error: 139_737 + .saturating_add(Weight::from_ref_time(31_455_000 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2011,9 +2185,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - Weight::from_ref_time(288_995_000 as u64) - // Standard Error: 51_161 - .saturating_add(Weight::from_ref_time(96_331_905 as u64).saturating_mul(n as u64)) + // Minimum execution time: 314_440 nanoseconds. + Weight::from_ref_time(317_795_000 as u64) + // Standard Error: 50_822 + .saturating_add(Weight::from_ref_time(96_256_697 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2024,9 +2199,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - Weight::from_ref_time(249_935_000 as u64) - // Standard Error: 662_188 - .saturating_add(Weight::from_ref_time(3_025_889_600 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_599 nanoseconds. + Weight::from_ref_time(289_683_557 as u64) + // Standard Error: 536_607 + .saturating_add(Weight::from_ref_time(3_008_499_142 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2037,9 +2213,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - Weight::from_ref_time(248_094_000 as u64) - // Standard Error: 535_446 - .saturating_add(Weight::from_ref_time(2_086_979_500 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_690 nanoseconds. + Weight::from_ref_time(289_027_440 as u64) + // Standard Error: 371_475 + .saturating_add(Weight::from_ref_time(2_049_105_659 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2051,318 +2228,370 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. fn seal_set_code_hash(r: u32, ) -> Weight { - Weight::from_ref_time(248_254_000 as u64) - // Standard Error: 1_340_955 - .saturating_add(Weight::from_ref_time(1_065_939_603 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_919 nanoseconds. + Weight::from_ref_time(288_356_000 as u64) + // Standard Error: 2_749_310 + .saturating_add(Weight::from_ref_time(1_358_240_619 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) - .saturating_add(RocksDbWeight::get().reads((150 as u64).saturating_mul(r as u64))) + .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) .saturating_add(RocksDbWeight::get().writes((150 as u64).saturating_mul(r as u64))) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - Weight::from_ref_time(70_705_000 as u64) - // Standard Error: 7_175 - .saturating_add(Weight::from_ref_time(983_586 as u64).saturating_mul(r as u64)) + // Minimum execution time: 633 nanoseconds. + Weight::from_ref_time(833_605 as u64) + // Standard Error: 256 + .saturating_add(Weight::from_ref_time(493_683 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - Weight::from_ref_time(69_659_000 as u64) - // Standard Error: 1_140 - .saturating_add(Weight::from_ref_time(3_004_307 as u64).saturating_mul(r as u64)) + // Minimum execution time: 772 nanoseconds. + Weight::from_ref_time(1_216_335 as u64) + // Standard Error: 506 + .saturating_add(Weight::from_ref_time(1_100_153 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - Weight::from_ref_time(69_621_000 as u64) - // Standard Error: 2_871 - .saturating_add(Weight::from_ref_time(2_715_451 as u64).saturating_mul(r as u64)) + // Minimum execution time: 752 nanoseconds. + Weight::from_ref_time(1_232_818 as u64) + // Standard Error: 509 + .saturating_add(Weight::from_ref_time(1_006_310 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - Weight::from_ref_time(69_459_000 as u64) - // Standard Error: 3_284 - .saturating_add(Weight::from_ref_time(2_581_283 as u64).saturating_mul(r as u64)) + // Minimum execution time: 636 nanoseconds. + Weight::from_ref_time(908_576 as u64) + // Standard Error: 223 + .saturating_add(Weight::from_ref_time(1_183_249 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - Weight::from_ref_time(69_558_000 as u64) - // Standard Error: 2_509 - .saturating_add(Weight::from_ref_time(2_906_689 as u64).saturating_mul(r as u64)) + // Minimum execution time: 654 nanoseconds. + Weight::from_ref_time(668_211 as u64) + // Standard Error: 1_202 + .saturating_add(Weight::from_ref_time(1_518_771 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - Weight::from_ref_time(69_407_000 as u64) - // Standard Error: 1_697 - .saturating_add(Weight::from_ref_time(1_702_534 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(859_213 as u64) + // Standard Error: 243 + .saturating_add(Weight::from_ref_time(669_217 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - Weight::from_ref_time(69_477_000 as u64) - // Standard Error: 1_733 - .saturating_add(Weight::from_ref_time(2_192_641 as u64).saturating_mul(r as u64)) + // Minimum execution time: 669 nanoseconds. + Weight::from_ref_time(811_434 as u64) + // Standard Error: 811 + .saturating_add(Weight::from_ref_time(932_974 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - Weight::from_ref_time(69_424_000 as u64) - // Standard Error: 2_096 - .saturating_add(Weight::from_ref_time(2_435_708 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(510_094 as u64) + // Standard Error: 1_793 + .saturating_add(Weight::from_ref_time(1_255_401 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - Weight::from_ref_time(72_883_000 as u64) - // Standard Error: 209 - .saturating_add(Weight::from_ref_time(6_874 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_454 nanoseconds. + Weight::from_ref_time(2_721_478 as u64) + // Standard Error: 52 + .saturating_add(Weight::from_ref_time(3_520 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - Weight::from_ref_time(69_422_000 as u64) - // Standard Error: 5_030 - .saturating_add(Weight::from_ref_time(7_638_087 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(1_524_706 as u64) + // Standard Error: 4_023 + .saturating_add(Weight::from_ref_time(2_429_512 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - Weight::from_ref_time(83_136_000 as u64) - // Standard Error: 7_751 - .saturating_add(Weight::from_ref_time(9_543_944 as u64).saturating_mul(r as u64)) + // Minimum execution time: 711 nanoseconds. + Weight::from_ref_time(1_576_545 as u64) + // Standard Error: 2_825 + .saturating_add(Weight::from_ref_time(3_063_132 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - Weight::from_ref_time(93_281_000 as u64) - // Standard Error: 1_967 - .saturating_add(Weight::from_ref_time(596_591 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_577 nanoseconds. + Weight::from_ref_time(5_305_612 as u64) + // Standard Error: 218 + .saturating_add(Weight::from_ref_time(207_324 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - Weight::from_ref_time(69_702_000 as u64) - // Standard Error: 1_112 - .saturating_add(Weight::from_ref_time(1_094_685 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_450 nanoseconds. + Weight::from_ref_time(1_746_256 as u64) + // Standard Error: 337 + .saturating_add(Weight::from_ref_time(609_345 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - Weight::from_ref_time(69_720_000 as u64) - // Standard Error: 1_768 - .saturating_add(Weight::from_ref_time(1_045_163 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_457 nanoseconds. + Weight::from_ref_time(1_699_261 as u64) + // Standard Error: 212 + .saturating_add(Weight::from_ref_time(512_774 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - Weight::from_ref_time(69_716_000 as u64) - // Standard Error: 1_000 - .saturating_add(Weight::from_ref_time(1_541_622 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_449 nanoseconds. + Weight::from_ref_time(1_726_109 as u64) + // Standard Error: 540 + .saturating_add(Weight::from_ref_time(722_939 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - Weight::from_ref_time(72_315_000 as u64) - // Standard Error: 1_081 - .saturating_add(Weight::from_ref_time(1_646_437 as u64).saturating_mul(r as u64)) + // Minimum execution time: 707 nanoseconds. + Weight::from_ref_time(1_012_945 as u64) + // Standard Error: 456 + .saturating_add(Weight::from_ref_time(978_825 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - Weight::from_ref_time(72_256_000 as u64) - // Standard Error: 1_749 - .saturating_add(Weight::from_ref_time(1_664_891 as u64).saturating_mul(r as u64)) + // Minimum execution time: 718 nanoseconds. + Weight::from_ref_time(991_713 as u64) + // Standard Error: 376 + .saturating_add(Weight::from_ref_time(958_921 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - Weight::from_ref_time(69_616_000 as u64) - // Standard Error: 1_303 - .saturating_add(Weight::from_ref_time(1_017_254 as u64).saturating_mul(r as u64)) + // Minimum execution time: 737 nanoseconds. + Weight::from_ref_time(1_003_536 as u64) + // Standard Error: 357 + .saturating_add(Weight::from_ref_time(753_905 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - Weight::from_ref_time(70_943_000 as u64) - // Standard Error: 120_139 - .saturating_add(Weight::from_ref_time(183_262_000 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(720_128 as u64) + // Standard Error: 3_756 + .saturating_add(Weight::from_ref_time(188_693_871 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - Weight::from_ref_time(70_953_000 as u64) - // Standard Error: 2_591 - .saturating_add(Weight::from_ref_time(1_458_584 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(892_350 as u64) + // Standard Error: 221 + .saturating_add(Weight::from_ref_time(672_006 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - Weight::from_ref_time(69_439_000 as u64) - // Standard Error: 1_822 - .saturating_add(Weight::from_ref_time(1_486_431 as u64).saturating_mul(r as u64)) + // Minimum execution time: 652 nanoseconds. + Weight::from_ref_time(921_248 as u64) + // Standard Error: 298 + .saturating_add(Weight::from_ref_time(671_631 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - Weight::from_ref_time(69_366_000 as u64) - // Standard Error: 2_674 - .saturating_add(Weight::from_ref_time(1_506_755 as u64).saturating_mul(r as u64)) + // Minimum execution time: 645 nanoseconds. + Weight::from_ref_time(890_444 as u64) + // Standard Error: 247 + .saturating_add(Weight::from_ref_time(672_057 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - Weight::from_ref_time(69_386_000 as u64) - // Standard Error: 3_040 - .saturating_add(Weight::from_ref_time(1_509_928 as u64).saturating_mul(r as u64)) + // Minimum execution time: 684 nanoseconds. + Weight::from_ref_time(910_228 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(684_713 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - Weight::from_ref_time(69_432_000 as u64) - // Standard Error: 1_875 - .saturating_add(Weight::from_ref_time(1_439_336 as u64).saturating_mul(r as u64)) + // Minimum execution time: 668 nanoseconds. + Weight::from_ref_time(874_456 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(671_242 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - Weight::from_ref_time(69_488_000 as u64) - // Standard Error: 1_654 - .saturating_add(Weight::from_ref_time(1_429_318 as u64).saturating_mul(r as u64)) + // Minimum execution time: 632 nanoseconds. + Weight::from_ref_time(900_807 as u64) + // Standard Error: 235 + .saturating_add(Weight::from_ref_time(670_298 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - Weight::from_ref_time(69_414_000 as u64) - // Standard Error: 2_773 - .saturating_add(Weight::from_ref_time(1_499_116 as u64).saturating_mul(r as u64)) + // Minimum execution time: 647 nanoseconds. + Weight::from_ref_time(910_984 as u64) + // Standard Error: 327 + .saturating_add(Weight::from_ref_time(671_129 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - Weight::from_ref_time(69_427_000 as u64) - // Standard Error: 2_404 - .saturating_add(Weight::from_ref_time(1_969_697 as u64).saturating_mul(r as u64)) + // Minimum execution time: 658 nanoseconds. + Weight::from_ref_time(895_986 as u64) + // Standard Error: 565 + .saturating_add(Weight::from_ref_time(913_649 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - Weight::from_ref_time(70_793_000 as u64) - // Standard Error: 1_765 - .saturating_add(Weight::from_ref_time(1_924_169 as u64).saturating_mul(r as u64)) + // Minimum execution time: 671 nanoseconds. + Weight::from_ref_time(892_539 as u64) + // Standard Error: 202 + .saturating_add(Weight::from_ref_time(913_503 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - Weight::from_ref_time(69_551_000 as u64) - // Standard Error: 3_955 - .saturating_add(Weight::from_ref_time(1_988_825 as u64).saturating_mul(r as u64)) + // Minimum execution time: 655 nanoseconds. + Weight::from_ref_time(960_186 as u64) + // Standard Error: 472 + .saturating_add(Weight::from_ref_time(922_417 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - Weight::from_ref_time(69_510_000 as u64) - // Standard Error: 3_797 - .saturating_add(Weight::from_ref_time(1_976_317 as u64).saturating_mul(r as u64)) + // Minimum execution time: 635 nanoseconds. + Weight::from_ref_time(870_482 as u64) + // Standard Error: 274 + .saturating_add(Weight::from_ref_time(914_130 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - Weight::from_ref_time(69_399_000 as u64) - // Standard Error: 3_255 - .saturating_add(Weight::from_ref_time(1_975_054 as u64).saturating_mul(r as u64)) + // Minimum execution time: 621 nanoseconds. + Weight::from_ref_time(891_451 as u64) + // Standard Error: 247 + .saturating_add(Weight::from_ref_time(909_133 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - Weight::from_ref_time(69_425_000 as u64) - // Standard Error: 1_738 - .saturating_add(Weight::from_ref_time(1_959_864 as u64).saturating_mul(r as u64)) + // Minimum execution time: 662 nanoseconds. + Weight::from_ref_time(904_400 as u64) + // Standard Error: 194 + .saturating_add(Weight::from_ref_time(917_254 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - Weight::from_ref_time(69_514_000 as u64) - // Standard Error: 9_227 - .saturating_add(Weight::from_ref_time(1_984_750 as u64).saturating_mul(r as u64)) + // Minimum execution time: 673 nanoseconds. + Weight::from_ref_time(913_787 as u64) + // Standard Error: 185 + .saturating_add(Weight::from_ref_time(911_025 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - Weight::from_ref_time(69_415_000 as u64) - // Standard Error: 2_052 - .saturating_add(Weight::from_ref_time(1_967_146 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(892_985 as u64) + // Standard Error: 175 + .saturating_add(Weight::from_ref_time(919_451 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - Weight::from_ref_time(69_348_000 as u64) - // Standard Error: 3_647 - .saturating_add(Weight::from_ref_time(1_996_141 as u64).saturating_mul(r as u64)) + // Minimum execution time: 666 nanoseconds. + Weight::from_ref_time(907_510 as u64) + // Standard Error: 204 + .saturating_add(Weight::from_ref_time(911_125 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - Weight::from_ref_time(69_448_000 as u64) - // Standard Error: 1_960 - .saturating_add(Weight::from_ref_time(1_956_889 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(896_012 as u64) + // Standard Error: 262 + .saturating_add(Weight::from_ref_time(911_762 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - Weight::from_ref_time(69_443_000 as u64) - // Standard Error: 20_301 - .saturating_add(Weight::from_ref_time(2_072_285 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(921_793 as u64) + // Standard Error: 220 + .saturating_add(Weight::from_ref_time(900_803 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - Weight::from_ref_time(69_458_000 as u64) - // Standard Error: 3_210 - .saturating_add(Weight::from_ref_time(1_970_367 as u64).saturating_mul(r as u64)) + // Minimum execution time: 676 nanoseconds. + Weight::from_ref_time(908_870 as u64) + // Standard Error: 277 + .saturating_add(Weight::from_ref_time(897_408 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - Weight::from_ref_time(69_429_000 as u64) - // Standard Error: 3_475 - .saturating_add(Weight::from_ref_time(1_977_800 as u64).saturating_mul(r as u64)) + // Minimum execution time: 671 nanoseconds. + Weight::from_ref_time(806_379 as u64) + // Standard Error: 638 + .saturating_add(Weight::from_ref_time(911_294 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - Weight::from_ref_time(69_414_000 as u64) - // Standard Error: 2_659 - .saturating_add(Weight::from_ref_time(2_797_503 as u64).saturating_mul(r as u64)) + // Minimum execution time: 639 nanoseconds. + Weight::from_ref_time(679_032 as u64) + // Standard Error: 6_536 + .saturating_add(Weight::from_ref_time(1_512_247 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - Weight::from_ref_time(69_460_000 as u64) - // Standard Error: 2_399 - .saturating_add(Weight::from_ref_time(2_646_574 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(864_336 as u64) + // Standard Error: 251 + .saturating_add(Weight::from_ref_time(1_361_436 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - Weight::from_ref_time(69_441_000 as u64) - // Standard Error: 2_179 - .saturating_add(Weight::from_ref_time(2_860_283 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(969_193 as u64) + // Standard Error: 333 + .saturating_add(Weight::from_ref_time(1_521_975 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - Weight::from_ref_time(69_401_000 as u64) - // Standard Error: 2_639 - .saturating_add(Weight::from_ref_time(2_582_137 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(869_301 as u64) + // Standard Error: 177 + .saturating_add(Weight::from_ref_time(1_361_528 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - Weight::from_ref_time(69_426_000 as u64) - // Standard Error: 2_379 - .saturating_add(Weight::from_ref_time(1_986_578 as u64).saturating_mul(r as u64)) + // Minimum execution time: 626 nanoseconds. + Weight::from_ref_time(883_738 as u64) + // Standard Error: 288 + .saturating_add(Weight::from_ref_time(901_730 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - Weight::from_ref_time(69_599_000 as u64) - // Standard Error: 2_918 - .saturating_add(Weight::from_ref_time(1_991_834 as u64).saturating_mul(r as u64)) + // Minimum execution time: 637 nanoseconds. + Weight::from_ref_time(892_052 as u64) + // Standard Error: 297 + .saturating_add(Weight::from_ref_time(901_479 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - Weight::from_ref_time(71_142_000 as u64) - // Standard Error: 2_659 - .saturating_add(Weight::from_ref_time(1_948_956 as u64).saturating_mul(r as u64)) + // Minimum execution time: 617 nanoseconds. + Weight::from_ref_time(882_714 as u64) + // Standard Error: 207 + .saturating_add(Weight::from_ref_time(901_984 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - Weight::from_ref_time(69_407_000 as u64) - // Standard Error: 4_100 - .saturating_add(Weight::from_ref_time(2_030_715 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(885_605 as u64) + // Standard Error: 329 + .saturating_add(Weight::from_ref_time(911_644 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - Weight::from_ref_time(69_534_000 as u64) - // Standard Error: 2_305 - .saturating_add(Weight::from_ref_time(1_989_346 as u64).saturating_mul(r as u64)) + // Minimum execution time: 655 nanoseconds. + Weight::from_ref_time(916_923 as u64) + // Standard Error: 219 + .saturating_add(Weight::from_ref_time(910_766 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - Weight::from_ref_time(69_432_000 as u64) - // Standard Error: 2_747 - .saturating_add(Weight::from_ref_time(2_002_548 as u64).saturating_mul(r as u64)) + // Minimum execution time: 688 nanoseconds. + Weight::from_ref_time(890_697 as u64) + // Standard Error: 224 + .saturating_add(Weight::from_ref_time(910_605 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - Weight::from_ref_time(69_465_000 as u64) - // Standard Error: 9_644 - .saturating_add(Weight::from_ref_time(2_045_830 as u64).saturating_mul(r as u64)) + // Minimum execution time: 679 nanoseconds. + Weight::from_ref_time(964_104 as u64) + // Standard Error: 658 + .saturating_add(Weight::from_ref_time(908_547 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - Weight::from_ref_time(69_435_000 as u64) - // Standard Error: 2_271 - .saturating_add(Weight::from_ref_time(2_001_986 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(879_488 as u64) + // Standard Error: 195 + .saturating_add(Weight::from_ref_time(910_911 as u64).saturating_mul(r as u64)) } } From e3d3dfb4a27b9667bf3e0390ec9c760dae9d5eb1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 30 Oct 2022 16:26:24 +0100 Subject: [PATCH 03/27] Re-check original code on re-instrumentation --- frame/contracts/src/schedule.rs | 2 +- frame/contracts/src/wasm/prepare.rs | 80 ++++++++++++++++++----------- 2 files changed, 51 insertions(+), 31 deletions(-) diff --git a/frame/contracts/src/schedule.rs b/frame/contracts/src/schedule.rs index 535517e756c61..6640068b9769f 100644 --- a/frame/contracts/src/schedule.rs +++ b/frame/contracts/src/schedule.rs @@ -532,7 +532,7 @@ impl Default for InstructionWeights { fn default() -> Self { let max_pages = Limits::default().memory_pages; Self { - version: 3, + version: 4, fallback: 0, i64const: cost_instr!(instr_i64const, 1), i64load: cost_instr!(instr_i64load, 2), diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 7b84397f31a2d..0161a5ebfd78c 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -41,12 +41,12 @@ pub const IMPORT_MODULE_MEMORY: &str = "env"; /// Determines whether a module should be instantiated during preparation. pub enum TryInstantiate { - /// Do the instantation to make sure that the module is valid. + /// Do the innstantiation to make sure that the module is valid. /// /// This should be used if a module is only uploaded but not executed. We need /// to make sure that it can be actually instantiated. Instantiate, - /// Skip the instantation during preparation. + /// Skip the instantiation during preparation. /// /// This makes sense when the preparation takes place as part of an instantation. Then /// this instantiation would fail the whole transaction and an extra check is not @@ -370,26 +370,19 @@ fn get_memory_limits( } } -/// Loads the given module given in `original_code`, performs some checks on it and -/// does some preprocessing. -/// -/// The checks are: -/// -/// - provided code is a valid wasm module. -/// - the module doesn't define an internal memory instance, -/// - imported memory (if any) doesn't reserve more memory than permitted by the `schedule`, -/// - all imported functions from the external environment matches defined by `env` module, +/// Check and instrument the given `original_code`. /// -/// The preprocessing includes injecting code for gas metering and metering the height of stack. -pub fn prepare( - original_code: CodeVec, +/// On success it returns the instrumented versions together with its `(initial, maximum)` +/// error requirement. The memory requirement was also validated against the `schedule`. +fn instrument( + original_code: &[u8], schedule: &Schedule, - owner: AccountIdOf, determinism: Determinism, try_instantiate: TryInstantiate, -) -> Result, (DispatchError, &'static str)> +) -> Result<(Vec, (u32, u32)), (DispatchError, &'static str)> where E: Environment<()>, + T: Config, T::AccountId: UncheckedFrom + AsRef<[u8]>, { // Do not enable any features here. Any additional feature needs to be carefully @@ -474,6 +467,35 @@ where })?; } + Ok((code, (initial, maximum))) +} + +/// Loads the given module given in `original_code`, performs some checks on it and +/// does some preprocessing. +/// +/// The checks are: +/// +/// - provided code is a valid wasm module. +/// - the module doesn't define an internal memory instance, +/// - imported memory (if any) doesn't reserve more memory than permitted by the `schedule`, +/// - all imported functions from the external environment matches defined by `env` module, +/// +/// The preprocessing includes injecting code for gas metering and metering the height of stack. +pub fn prepare( + original_code: CodeVec, + schedule: &Schedule, + owner: AccountIdOf, + determinism: Determinism, + try_instantiate: TryInstantiate, +) -> Result, (DispatchError, &'static str)> +where + E: Environment<()>, + T: Config, + T::AccountId: UncheckedFrom + AsRef<[u8]>, +{ + let (code, (initial, maximum)) = + instrument::(original_code.as_ref(), schedule, determinism, try_instantiate)?; + let original_code_len = original_code.len(); let mut module = PrefabWasmModule { @@ -502,30 +524,28 @@ where Ok(module) } -/// Just run the instrumentation without checking the code. +/// Same as [`prepare`] but without constructing a new module. /// -/// Only run this on already uploaded code which is already validated. This also doesn't -/// check new newly instrumented code as there is nothing we can do on a failure here -/// anyways: The code is already deployed and it doesn't matter if it fails here or when -/// actually running the code. -pub fn reinstrument( +/// Used to update the code of an existing module to the newest [`Schedule`] version. +/// Stictly speaking is not necessary to check the existing code before reinstrumenting because +/// it can't change in the meantime. However, since we recently switched the validation library +/// we want to re-validate to weed out any bugs that were lurking in the old version. +pub fn reinstrument( original_code: &[u8], schedule: &Schedule, determinism: Determinism, -) -> Result, &'static str> +) -> Result, DispatchError> where E: Environment<()>, + T: Config, T::AccountId: UncheckedFrom + AsRef<[u8]>, { - let contract_module = ContractModule::new(original_code, schedule)?; - contract_module - .inject_gas_metering(determinism) - .and_then(|module| module.inject_stack_height_metering()) - .and_then(|module| module.into_wasm_code()) - .map_err(|msg| { + instrument::(original_code, schedule, determinism, TryInstantiate::Skip) + .map_err(|(err, msg)| { log::error!(target: "runtime::contracts", "CodeRejected during reinstrument: {}", msg); - Error::::CodeRejected.into() + err }) + .map(|(code, _)| code) } /// Alternate (possibly unsafe) preparation functions used only for benchmarking. From 0386a5567844635f81be9c333aeb6f890e233a5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 30 Oct 2022 19:44:40 +0100 Subject: [PATCH 04/27] Fix clippy --- frame/contracts/src/wasm/prepare.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 0161a5ebfd78c..c61e56914e1db 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -411,14 +411,14 @@ where reference_types: false, simd: false, }) - .validate_all(original_code.as_ref()) + .validate_all(original_code) .map_err(|err| { log::debug!(target: "runtime::contracts", "{}", err); (Error::::CodeRejected.into(), "validation of new code failed") })?; let (code, (initial, maximum)) = (|| { - let contract_module = ContractModule::new(original_code.as_ref(), schedule)?; + let contract_module = ContractModule::new(original_code, schedule)?; contract_module.scan_exports()?; contract_module.ensure_no_internal_memory()?; contract_module.ensure_table_size_limit(schedule.limits.table_size)?; @@ -456,7 +456,7 @@ where // reduces the amount of memory that needs to be zeroed. let stack_limits = StackLimits::new(1, 1, 0).expect("initial <= max; qed"); PrefabWasmModule::::instantiate::( - original_code.as_ref(), + original_code, (), (initial, maximum), stack_limits, From 29a48fea03939ab87cb8f2019d0cc31d7fe821b6 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Mon, 31 Oct 2022 16:29:21 +0000 Subject: [PATCH 05/27] ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts --- frame/contracts/src/weights.rs | 1798 ++++++++++++++++---------------- 1 file changed, 899 insertions(+), 899 deletions(-) diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index 168bd25f3a7c9..ecc59eb9c6510 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -18,7 +18,7 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-10-28, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-10-31, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 @@ -168,17 +168,17 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 2_919 nanoseconds. - Weight::from_ref_time(3_033_000 as u64) + // Minimum execution time: 2_931 nanoseconds. + Weight::from_ref_time(3_115_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 14_627 nanoseconds. - Weight::from_ref_time(16_018_897 as u64) - // Standard Error: 824 - .saturating_add(Weight::from_ref_time(893_332 as u64).saturating_mul(k as u64)) + // Minimum execution time: 15_035 nanoseconds. + Weight::from_ref_time(15_007_164 as u64) + // Standard Error: 986 + .saturating_add(Weight::from_ref_time(900_803 as u64).saturating_mul(k as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -186,10 +186,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 2_867 nanoseconds. - Weight::from_ref_time(13_411_793 as u64) - // Standard Error: 5_268 - .saturating_add(Weight::from_ref_time(1_244_288 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_060 nanoseconds. + Weight::from_ref_time(15_200_003 as u64) + // Standard Error: 3_323 + .saturating_add(Weight::from_ref_time(1_244_355 as u64).saturating_mul(q as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -197,10 +197,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 20_987 nanoseconds. - Weight::from_ref_time(24_245_898 as u64) - // Standard Error: 48 - .saturating_add(Weight::from_ref_time(34_792 as u64).saturating_mul(c as u64)) + // Minimum execution time: 28_377 nanoseconds. + Weight::from_ref_time(20_120_669 as u64) + // Standard Error: 60 + .saturating_add(Weight::from_ref_time(49_221 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -211,10 +211,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 299_074 nanoseconds. - Weight::from_ref_time(306_372_889 as u64) - // Standard Error: 25 - .saturating_add(Weight::from_ref_time(30_663 as u64).saturating_mul(c as u64)) + // Minimum execution time: 293_993 nanoseconds. + Weight::from_ref_time(313_583_072 as u64) + // Standard Error: 23 + .saturating_add(Weight::from_ref_time(30_370 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -229,12 +229,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_072_174 nanoseconds. - Weight::from_ref_time(337_874_723 as u64) - // Standard Error: 73 - .saturating_add(Weight::from_ref_time(88_343 as u64).saturating_mul(c as u64)) + // Minimum execution time: 2_076_093 nanoseconds. + Weight::from_ref_time(317_276_951 as u64) + // Standard Error: 70 + .saturating_add(Weight::from_ref_time(92_182 as u64).saturating_mul(c as u64)) // Standard Error: 4 - .saturating_add(Weight::from_ref_time(1_695 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_719 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } @@ -247,10 +247,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 178_787 nanoseconds. - Weight::from_ref_time(171_072_954 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_447 as u64).saturating_mul(s as u64)) + // Minimum execution time: 179_314 nanoseconds. + Weight::from_ref_time(172_604_510 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_451 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } @@ -260,8 +260,8 @@ impl WeightInfo for SubstrateWeight { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 147_880 nanoseconds. - Weight::from_ref_time(149_054_000 as u64) + // Minimum execution time: 147_799 nanoseconds. + Weight::from_ref_time(149_370_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -271,10 +271,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 281_951 nanoseconds. - Weight::from_ref_time(296_591_045 as u64) - // Standard Error: 59 - .saturating_add(Weight::from_ref_time(75_741 as u64).saturating_mul(c as u64)) + // Minimum execution time: 282_031 nanoseconds. + Weight::from_ref_time(298_764_288 as u64) + // Standard Error: 64 + .saturating_add(Weight::from_ref_time(79_500 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -283,8 +283,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 38_314 nanoseconds. - Weight::from_ref_time(39_208_000 as u64) + // Minimum execution time: 39_154 nanoseconds. + Weight::from_ref_time(39_913_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -292,8 +292,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 40_821 nanoseconds. - Weight::from_ref_time(41_085_000 as u64) + // Minimum execution time: 40_761 nanoseconds. + Weight::from_ref_time(41_352_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } @@ -304,10 +304,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 283_566 nanoseconds. - Weight::from_ref_time(291_662_997 as u64) - // Standard Error: 26_198 - .saturating_add(Weight::from_ref_time(15_812_705 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_740 nanoseconds. + Weight::from_ref_time(291_554_435 as u64) + // Standard Error: 37_422 + .saturating_add(Weight::from_ref_time(15_763_400 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -318,10 +318,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 283_050 nanoseconds. - Weight::from_ref_time(231_589_172 as u64) - // Standard Error: 457_107 - .saturating_add(Weight::from_ref_time(194_493_604 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_398 nanoseconds. + Weight::from_ref_time(227_488_874 as u64) + // Standard Error: 475_749 + .saturating_add(Weight::from_ref_time(191_273_619 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -333,10 +333,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 289_561 nanoseconds. - Weight::from_ref_time(241_544_282 as u64) - // Standard Error: 439_485 - .saturating_add(Weight::from_ref_time(234_068_306 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_004 nanoseconds. + Weight::from_ref_time(240_522_081 as u64) + // Standard Error: 465_475 + .saturating_add(Weight::from_ref_time(233_370_074 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -348,10 +348,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 284_800 nanoseconds. - Weight::from_ref_time(292_300_021 as u64) - // Standard Error: 40_833 - .saturating_add(Weight::from_ref_time(19_473_073 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_980 nanoseconds. + Weight::from_ref_time(293_143_705 as u64) + // Standard Error: 31_246 + .saturating_add(Weight::from_ref_time(19_336_451 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -362,10 +362,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 286_811 nanoseconds. - Weight::from_ref_time(289_605_062 as u64) - // Standard Error: 17_481 - .saturating_add(Weight::from_ref_time(11_088_146 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_954 nanoseconds. + Weight::from_ref_time(290_721_695 as u64) + // Standard Error: 18_098 + .saturating_add(Weight::from_ref_time(10_760_625 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -376,10 +376,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 284_389 nanoseconds. - Weight::from_ref_time(291_607_958 as u64) - // Standard Error: 33_895 - .saturating_add(Weight::from_ref_time(15_781_940 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_009 nanoseconds. + Weight::from_ref_time(290_691_942 as u64) + // Standard Error: 31_912 + .saturating_add(Weight::from_ref_time(15_739_831 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -390,10 +390,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 282_896 nanoseconds. - Weight::from_ref_time(289_802_376 as u64) - // Standard Error: 33_013 - .saturating_add(Weight::from_ref_time(15_705_525 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_020 nanoseconds. + Weight::from_ref_time(290_217_625 as u64) + // Standard Error: 32_889 + .saturating_add(Weight::from_ref_time(15_564_753 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -404,10 +404,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 284_380 nanoseconds. - Weight::from_ref_time(291_136_750 as u64) - // Standard Error: 92_026 - .saturating_add(Weight::from_ref_time(86_938_178 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_291 nanoseconds. + Weight::from_ref_time(300_497_640 as u64) + // Standard Error: 81_211 + .saturating_add(Weight::from_ref_time(88_485_235 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -418,10 +418,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 286_734 nanoseconds. - Weight::from_ref_time(290_556_604 as u64) - // Standard Error: 31_726 - .saturating_add(Weight::from_ref_time(15_580_656 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_704 nanoseconds. + Weight::from_ref_time(289_980_711 as u64) + // Standard Error: 19_233 + .saturating_add(Weight::from_ref_time(15_794_847 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -432,10 +432,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 282_935 nanoseconds. - Weight::from_ref_time(290_693_236 as u64) - // Standard Error: 24_862 - .saturating_add(Weight::from_ref_time(15_421_306 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_969 nanoseconds. + Weight::from_ref_time(289_628_583 as u64) + // Standard Error: 31_071 + .saturating_add(Weight::from_ref_time(15_512_708 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -446,10 +446,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 287_010 nanoseconds. - Weight::from_ref_time(290_738_164 as u64) - // Standard Error: 20_205 - .saturating_add(Weight::from_ref_time(15_237_554 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_738 nanoseconds. + Weight::from_ref_time(290_782_451 as u64) + // Standard Error: 28_491 + .saturating_add(Weight::from_ref_time(15_480_085 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -460,10 +460,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 286_862 nanoseconds. - Weight::from_ref_time(291_029_188 as u64) - // Standard Error: 30_491 - .saturating_add(Weight::from_ref_time(15_450_941 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_761 nanoseconds. + Weight::from_ref_time(291_086_703 as u64) + // Standard Error: 25_134 + .saturating_add(Weight::from_ref_time(15_389_582 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -475,10 +475,10 @@ impl WeightInfo for SubstrateWeight { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 283_725 nanoseconds. - Weight::from_ref_time(293_071_360 as u64) - // Standard Error: 97_620 - .saturating_add(Weight::from_ref_time(85_454_560 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_456 nanoseconds. + Weight::from_ref_time(293_334_784 as u64) + // Standard Error: 84_335 + .saturating_add(Weight::from_ref_time(87_972_926 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -489,10 +489,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 135_545 nanoseconds. - Weight::from_ref_time(139_022_047 as u64) - // Standard Error: 9_547 - .saturating_add(Weight::from_ref_time(7_859_219 as u64).saturating_mul(r as u64)) + // Minimum execution time: 135_621 nanoseconds. + Weight::from_ref_time(138_776_095 as u64) + // Standard Error: 9_723 + .saturating_add(Weight::from_ref_time(7_833_191 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -503,10 +503,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 283_396 nanoseconds. - Weight::from_ref_time(291_462_361 as u64) - // Standard Error: 28_397 - .saturating_add(Weight::from_ref_time(13_492_690 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_231 nanoseconds. + Weight::from_ref_time(290_476_129 as u64) + // Standard Error: 21_078 + .saturating_add(Weight::from_ref_time(13_426_746 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -517,10 +517,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 302_871 nanoseconds. - Weight::from_ref_time(320_897_273 as u64) - // Standard Error: 3_496 - .saturating_add(Weight::from_ref_time(9_614_024 as u64).saturating_mul(n as u64)) + // Minimum execution time: 298_683 nanoseconds. + Weight::from_ref_time(324_926_199 as u64) + // Standard Error: 3_973 + .saturating_add(Weight::from_ref_time(9_603_913 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -531,10 +531,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 280_519 nanoseconds. - Weight::from_ref_time(286_177_785 as u64) - // Standard Error: 101_357 - .saturating_add(Weight::from_ref_time(888_714 as u64).saturating_mul(r as u64)) + // Minimum execution time: 277_985 nanoseconds. + Weight::from_ref_time(286_423_097 as u64) + // Standard Error: 130_406 + .saturating_add(Weight::from_ref_time(891_202 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -545,10 +545,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 285_901 nanoseconds. - Weight::from_ref_time(287_315_127 as u64) - // Standard Error: 877 - .saturating_add(Weight::from_ref_time(190_891 as u64).saturating_mul(n as u64)) + // Minimum execution time: 283_769 nanoseconds. + Weight::from_ref_time(287_958_946 as u64) + // Standard Error: 668 + .saturating_add(Weight::from_ref_time(187_637 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -561,10 +561,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 282_147 nanoseconds. - Weight::from_ref_time(287_753_920 as u64) - // Standard Error: 99_065 - .saturating_add(Weight::from_ref_time(53_786_379 as u64).saturating_mul(r as u64)) + // Minimum execution time: 278_534 nanoseconds. + Weight::from_ref_time(287_780_036 as u64) + // Standard Error: 129_466 + .saturating_add(Weight::from_ref_time(53_007_763 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -578,10 +578,10 @@ impl WeightInfo for SubstrateWeight { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 282_779 nanoseconds. - Weight::from_ref_time(295_701_851 as u64) - // Standard Error: 92_851 - .saturating_add(Weight::from_ref_time(106_176_241 as u64).saturating_mul(r as u64)) + // Minimum execution time: 278_493 nanoseconds. + Weight::from_ref_time(290_592_257 as u64) + // Standard Error: 94_173 + .saturating_add(Weight::from_ref_time(107_930_905 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -592,10 +592,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 281_392 nanoseconds. - Weight::from_ref_time(296_151_487 as u64) - // Standard Error: 117_012 - .saturating_add(Weight::from_ref_time(222_546_893 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_247 nanoseconds. + Weight::from_ref_time(296_142_593 as u64) + // Standard Error: 96_546 + .saturating_add(Weight::from_ref_time(218_331_111 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -607,12 +607,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_192_807 nanoseconds. - Weight::from_ref_time(506_881_525 as u64) - // Standard Error: 443_155 - .saturating_add(Weight::from_ref_time(177_724_866 as u64).saturating_mul(t as u64)) - // Standard Error: 121_711 - .saturating_add(Weight::from_ref_time(67_213_725 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_180_712 nanoseconds. + Weight::from_ref_time(493_002_751 as u64) + // Standard Error: 533_813 + .saturating_add(Weight::from_ref_time(177_505_380 as u64).saturating_mul(t as u64)) + // Standard Error: 146_611 + .saturating_add(Weight::from_ref_time(67_941_198 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -625,20 +625,20 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 148_269 nanoseconds. - Weight::from_ref_time(152_128_988 as u64) - // Standard Error: 16_981 - .saturating_add(Weight::from_ref_time(12_691_070 as u64).saturating_mul(r as u64)) + // Minimum execution time: 148_732 nanoseconds. + Weight::from_ref_time(152_227_471 as u64) + // Standard Error: 19_202 + .saturating_add(Weight::from_ref_time(12_568_111 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 284_194 nanoseconds. - Weight::from_ref_time(249_462_948 as u64) - // Standard Error: 420_603 - .saturating_add(Weight::from_ref_time(382_005_385 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_482 nanoseconds. + Weight::from_ref_time(243_156_068 as u64) + // Standard Error: 474_497 + .saturating_add(Weight::from_ref_time(388_742_860 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -647,10 +647,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 416_372 nanoseconds. - Weight::from_ref_time(558_600_043 as u64) - // Standard Error: 1_283_845 - .saturating_add(Weight::from_ref_time(87_356_639 as u64).saturating_mul(n as u64)) + // Minimum execution time: 414_293 nanoseconds. + Weight::from_ref_time(559_267_738 as u64) + // Standard Error: 1_303_216 + .saturating_add(Weight::from_ref_time(90_036_803 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(52 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(50 as u64)) @@ -659,10 +659,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 414_605 nanoseconds. - Weight::from_ref_time(531_590_681 as u64) - // Standard Error: 1_081_636 - .saturating_add(Weight::from_ref_time(61_988_451 as u64).saturating_mul(n as u64)) + // Minimum execution time: 414_033 nanoseconds. + Weight::from_ref_time(532_231_525 as u64) + // Standard Error: 1_055_953 + .saturating_add(Weight::from_ref_time(62_435_646 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(49 as u64)) @@ -671,10 +671,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 284_561 nanoseconds. - Weight::from_ref_time(247_133_699 as u64) - // Standard Error: 430_882 - .saturating_add(Weight::from_ref_time(380_288_678 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_504 nanoseconds. + Weight::from_ref_time(246_435_673 as u64) + // Standard Error: 453_053 + .saturating_add(Weight::from_ref_time(380_783_741 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -683,10 +683,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 385_375 nanoseconds. - Weight::from_ref_time(515_998_814 as u64) - // Standard Error: 1_205_946 - .saturating_add(Weight::from_ref_time(63_741_054 as u64).saturating_mul(n as u64)) + // Minimum execution time: 382_408 nanoseconds. + Weight::from_ref_time(512_746_664 as u64) + // Standard Error: 1_172_067 + .saturating_add(Weight::from_ref_time(65_032_243 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -695,10 +695,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 284_047 nanoseconds. - Weight::from_ref_time(258_952_780 as u64) - // Standard Error: 359_810 - .saturating_add(Weight::from_ref_time(299_965_622 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_790 nanoseconds. + Weight::from_ref_time(257_076_625 as u64) + // Standard Error: 403_694 + .saturating_add(Weight::from_ref_time(302_599_469 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -706,10 +706,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 364_719 nanoseconds. - Weight::from_ref_time(479_168_397 as u64) - // Standard Error: 1_056_296 - .saturating_add(Weight::from_ref_time(148_008_433 as u64).saturating_mul(n as u64)) + // Minimum execution time: 360_774 nanoseconds. + Weight::from_ref_time(477_765_083 as u64) + // Standard Error: 1_054_248 + .saturating_add(Weight::from_ref_time(149_132_576 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -717,10 +717,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 285_860 nanoseconds. - Weight::from_ref_time(260_444_355 as u64) - // Standard Error: 354_017 - .saturating_add(Weight::from_ref_time(285_201_666 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_275 nanoseconds. + Weight::from_ref_time(257_256_687 as u64) + // Standard Error: 390_455 + .saturating_add(Weight::from_ref_time(288_646_973 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -728,10 +728,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 359_457 nanoseconds. - Weight::from_ref_time(459_211_204 as u64) - // Standard Error: 912_412 - .saturating_add(Weight::from_ref_time(56_532_346 as u64).saturating_mul(n as u64)) + // Minimum execution time: 359_931 nanoseconds. + Weight::from_ref_time(458_152_093 as u64) + // Standard Error: 892_824 + .saturating_add(Weight::from_ref_time(57_758_562 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -739,10 +739,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 285_064 nanoseconds. - Weight::from_ref_time(246_043_797 as u64) - // Standard Error: 442_983 - .saturating_add(Weight::from_ref_time(392_246_113 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_231 nanoseconds. + Weight::from_ref_time(244_165_075 as u64) + // Standard Error: 473_122 + .saturating_add(Weight::from_ref_time(393_316_438 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -751,10 +751,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 387_629 nanoseconds. - Weight::from_ref_time(529_491_574 as u64) - // Standard Error: 1_311_955 - .saturating_add(Weight::from_ref_time(155_160_167 as u64).saturating_mul(n as u64)) + // Minimum execution time: 387_247 nanoseconds. + Weight::from_ref_time(531_048_473 as u64) + // Standard Error: 1_295_482 + .saturating_add(Weight::from_ref_time(155_055_305 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -767,10 +767,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 287_827 nanoseconds. - Weight::from_ref_time(226_727_998 as u64) - // Standard Error: 758_553 - .saturating_add(Weight::from_ref_time(1_311_899_729 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_950 nanoseconds. + Weight::from_ref_time(247_687_017 as u64) + // Standard Error: 701_992 + .saturating_add(Weight::from_ref_time(1_334_157_964 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -783,10 +783,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 286_474 nanoseconds. - Weight::from_ref_time(290_308_000 as u64) - // Standard Error: 6_440_996 - .saturating_add(Weight::from_ref_time(20_239_024_486 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_248 nanoseconds. + Weight::from_ref_time(289_718_000 as u64) + // Standard Error: 6_905_454 + .saturating_add(Weight::from_ref_time(20_181_920_493 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -799,10 +799,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 288_054 nanoseconds. - Weight::from_ref_time(290_468_000 as u64) - // Standard Error: 6_594_354 - .saturating_add(Weight::from_ref_time(20_004_202_621 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_335 nanoseconds. + Weight::from_ref_time(290_342_000 as u64) + // Standard Error: 6_735_691 + .saturating_add(Weight::from_ref_time(19_874_310_103 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -816,12 +816,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 9_023_111 nanoseconds. - Weight::from_ref_time(8_008_697_453 as u64) - // Standard Error: 6_164_150 - .saturating_add(Weight::from_ref_time(1_242_557_423 as u64).saturating_mul(t as u64)) - // Standard Error: 9_242 - .saturating_add(Weight::from_ref_time(9_790_280 as u64).saturating_mul(c as u64)) + // Minimum execution time: 8_973_394 nanoseconds. + Weight::from_ref_time(7_928_586_368 as u64) + // Standard Error: 6_427_011 + .saturating_add(Weight::from_ref_time(1_276_828_100 as u64).saturating_mul(t as u64)) + // Standard Error: 9_636 + .saturating_add(Weight::from_ref_time(9_833_968 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(167 as u64)) .saturating_add(T::DbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(163 as u64)) @@ -836,10 +836,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 286_837 nanoseconds. - Weight::from_ref_time(291_218_000 as u64) - // Standard Error: 19_786_457 - .saturating_add(Weight::from_ref_time(25_510_029_458 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_929 nanoseconds. + Weight::from_ref_time(289_843_000 as u64) + // Standard Error: 20_434_247 + .saturating_add(Weight::from_ref_time(25_448_464_329 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(5 as u64)) @@ -855,10 +855,10 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 11_068_335 nanoseconds. - Weight::from_ref_time(10_796_296_013 as u64) - // Standard Error: 76_863 - .saturating_add(Weight::from_ref_time(119_227_442 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_073_432 nanoseconds. + Weight::from_ref_time(10_946_295_951 as u64) + // Standard Error: 81_481 + .saturating_add(Weight::from_ref_time(119_266_558 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(249 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(247 as u64)) @@ -871,10 +871,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 283_120 nanoseconds. - Weight::from_ref_time(289_308_957 as u64) - // Standard Error: 166_497 - .saturating_add(Weight::from_ref_time(41_451_242 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_830 nanoseconds. + Weight::from_ref_time(290_209_802 as u64) + // Standard Error: 169_549 + .saturating_add(Weight::from_ref_time(43_035_497 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -885,10 +885,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 329_812 nanoseconds. - Weight::from_ref_time(330_612_000 as u64) - // Standard Error: 53_026 - .saturating_add(Weight::from_ref_time(322_254_314 as u64).saturating_mul(n as u64)) + // Minimum execution time: 328_452 nanoseconds. + Weight::from_ref_time(331_955_000 as u64) + // Standard Error: 48_357 + .saturating_add(Weight::from_ref_time(322_126_385 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -899,10 +899,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 283_513 nanoseconds. - Weight::from_ref_time(288_770_253 as u64) - // Standard Error: 127_481 - .saturating_add(Weight::from_ref_time(54_024_646 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_512 nanoseconds. + Weight::from_ref_time(289_141_330 as u64) + // Standard Error: 139_948 + .saturating_add(Weight::from_ref_time(53_676_369 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -913,10 +913,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 337_526 nanoseconds. - Weight::from_ref_time(341_798_000 as u64) - // Standard Error: 55_732 - .saturating_add(Weight::from_ref_time(246_278_245 as u64).saturating_mul(n as u64)) + // Minimum execution time: 337_000 nanoseconds. + Weight::from_ref_time(341_992_000 as u64) + // Standard Error: 63_898 + .saturating_add(Weight::from_ref_time(246_190_881 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -927,10 +927,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 282_755 nanoseconds. - Weight::from_ref_time(288_770_457 as u64) - // Standard Error: 126_198 - .saturating_add(Weight::from_ref_time(31_005_842 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_082 nanoseconds. + Weight::from_ref_time(289_205_383 as u64) + // Standard Error: 147_477 + .saturating_add(Weight::from_ref_time(31_447_316 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -941,10 +941,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 318_456 nanoseconds. - Weight::from_ref_time(319_657_000 as u64) - // Standard Error: 48_627 - .saturating_add(Weight::from_ref_time(96_235_891 as u64).saturating_mul(n as u64)) + // Minimum execution time: 317_203 nanoseconds. + Weight::from_ref_time(320_227_000 as u64) + // Standard Error: 60_664 + .saturating_add(Weight::from_ref_time(96_574_720 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -955,10 +955,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 279_514 nanoseconds. - Weight::from_ref_time(286_965_600 as u64) - // Standard Error: 139_737 - .saturating_add(Weight::from_ref_time(31_455_000 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_129 nanoseconds. + Weight::from_ref_time(287_316_563 as u64) + // Standard Error: 344_649 + .saturating_add(Weight::from_ref_time(36_089_836 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -969,10 +969,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 314_440 nanoseconds. - Weight::from_ref_time(317_795_000 as u64) - // Standard Error: 50_822 - .saturating_add(Weight::from_ref_time(96_256_697 as u64).saturating_mul(n as u64)) + // Minimum execution time: 313_600 nanoseconds. + Weight::from_ref_time(318_372_000 as u64) + // Standard Error: 60_022 + .saturating_add(Weight::from_ref_time(96_662_276 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -983,10 +983,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 283_599 nanoseconds. - Weight::from_ref_time(289_683_557 as u64) - // Standard Error: 536_607 - .saturating_add(Weight::from_ref_time(3_008_499_142 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_253 nanoseconds. + Weight::from_ref_time(289_841_369 as u64) + // Standard Error: 720_896 + .saturating_add(Weight::from_ref_time(3_014_326_830 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -997,10 +997,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 283_690 nanoseconds. - Weight::from_ref_time(289_027_440 as u64) - // Standard Error: 371_475 - .saturating_add(Weight::from_ref_time(2_049_105_659 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_063 nanoseconds. + Weight::from_ref_time(289_066_912 as u64) + // Standard Error: 444_023 + .saturating_add(Weight::from_ref_time(2_044_352_087 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1012,10 +1012,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 283_919 nanoseconds. - Weight::from_ref_time(288_356_000 as u64) - // Standard Error: 2_749_310 - .saturating_add(Weight::from_ref_time(1_358_240_619 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_089 nanoseconds. + Weight::from_ref_time(286_104_000 as u64) + // Standard Error: 2_723_838 + .saturating_add(Weight::from_ref_time(1_364_603_517 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -1023,360 +1023,360 @@ impl WeightInfo for SubstrateWeight { } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 633 nanoseconds. - Weight::from_ref_time(833_605 as u64) - // Standard Error: 256 - .saturating_add(Weight::from_ref_time(493_683 as u64).saturating_mul(r as u64)) + // Minimum execution time: 710 nanoseconds. + Weight::from_ref_time(923_784 as u64) + // Standard Error: 272 + .saturating_add(Weight::from_ref_time(493_874 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 772 nanoseconds. - Weight::from_ref_time(1_216_335 as u64) - // Standard Error: 506 - .saturating_add(Weight::from_ref_time(1_100_153 as u64).saturating_mul(r as u64)) + // Minimum execution time: 781 nanoseconds. + Weight::from_ref_time(1_275_543 as u64) + // Standard Error: 1_135 + .saturating_add(Weight::from_ref_time(1_111_569 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 752 nanoseconds. - Weight::from_ref_time(1_232_818 as u64) - // Standard Error: 509 - .saturating_add(Weight::from_ref_time(1_006_310 as u64).saturating_mul(r as u64)) + // Minimum execution time: 786 nanoseconds. + Weight::from_ref_time(1_145_302 as u64) + // Standard Error: 972 + .saturating_add(Weight::from_ref_time(1_020_583 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 636 nanoseconds. - Weight::from_ref_time(908_576 as u64) - // Standard Error: 223 - .saturating_add(Weight::from_ref_time(1_183_249 as u64).saturating_mul(r as u64)) + // Minimum execution time: 647 nanoseconds. + Weight::from_ref_time(976_972 as u64) + // Standard Error: 331 + .saturating_add(Weight::from_ref_time(1_187_260 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 654 nanoseconds. - Weight::from_ref_time(668_211 as u64) - // Standard Error: 1_202 - .saturating_add(Weight::from_ref_time(1_518_771 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(686_941 as u64) + // Standard Error: 450 + .saturating_add(Weight::from_ref_time(1_530_719 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 660 nanoseconds. - Weight::from_ref_time(859_213 as u64) - // Standard Error: 243 - .saturating_add(Weight::from_ref_time(669_217 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(930_669 as u64) + // Standard Error: 396 + .saturating_add(Weight::from_ref_time(669_802 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 669 nanoseconds. - Weight::from_ref_time(811_434 as u64) - // Standard Error: 811 - .saturating_add(Weight::from_ref_time(932_974 as u64).saturating_mul(r as u64)) + // Minimum execution time: 701 nanoseconds. + Weight::from_ref_time(981_928 as u64) + // Standard Error: 826 + .saturating_add(Weight::from_ref_time(923_573 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 670 nanoseconds. - Weight::from_ref_time(510_094 as u64) - // Standard Error: 1_793 - .saturating_add(Weight::from_ref_time(1_255_401 as u64).saturating_mul(r as u64)) + // Minimum execution time: 697 nanoseconds. + Weight::from_ref_time(697_538 as u64) + // Standard Error: 1_419 + .saturating_add(Weight::from_ref_time(1_245_656 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 2_454 nanoseconds. - Weight::from_ref_time(2_721_478 as u64) - // Standard Error: 52 - .saturating_add(Weight::from_ref_time(3_520 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_581 nanoseconds. + Weight::from_ref_time(2_805_373 as u64) + // Standard Error: 55 + .saturating_add(Weight::from_ref_time(3_664 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(1_524_706 as u64) - // Standard Error: 4_023 - .saturating_add(Weight::from_ref_time(2_429_512 as u64).saturating_mul(r as u64)) + // Minimum execution time: 681 nanoseconds. + Weight::from_ref_time(1_346_495 as u64) + // Standard Error: 1_793 + .saturating_add(Weight::from_ref_time(2_362_769 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 711 nanoseconds. - Weight::from_ref_time(1_576_545 as u64) - // Standard Error: 2_825 - .saturating_add(Weight::from_ref_time(3_063_132 as u64).saturating_mul(r as u64)) + // Minimum execution time: 791 nanoseconds. + Weight::from_ref_time(2_082_854 as u64) + // Standard Error: 1_898 + .saturating_add(Weight::from_ref_time(3_004_674 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 4_577 nanoseconds. - Weight::from_ref_time(5_305_612 as u64) - // Standard Error: 218 - .saturating_add(Weight::from_ref_time(207_324 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_565 nanoseconds. + Weight::from_ref_time(5_403_098 as u64) + // Standard Error: 268 + .saturating_add(Weight::from_ref_time(208_007 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 1_450 nanoseconds. - Weight::from_ref_time(1_746_256 as u64) - // Standard Error: 337 - .saturating_add(Weight::from_ref_time(609_345 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_435 nanoseconds. + Weight::from_ref_time(1_817_646 as u64) + // Standard Error: 328 + .saturating_add(Weight::from_ref_time(609_595 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 1_457 nanoseconds. - Weight::from_ref_time(1_699_261 as u64) - // Standard Error: 212 - .saturating_add(Weight::from_ref_time(512_774 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_505 nanoseconds. + Weight::from_ref_time(1_787_731 as u64) + // Standard Error: 278 + .saturating_add(Weight::from_ref_time(512_746 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 1_449 nanoseconds. - Weight::from_ref_time(1_726_109 as u64) - // Standard Error: 540 - .saturating_add(Weight::from_ref_time(722_939 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_480 nanoseconds. + Weight::from_ref_time(1_799_405 as u64) + // Standard Error: 487 + .saturating_add(Weight::from_ref_time(722_985 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 707 nanoseconds. - Weight::from_ref_time(1_012_945 as u64) - // Standard Error: 456 - .saturating_add(Weight::from_ref_time(978_825 as u64).saturating_mul(r as u64)) + // Minimum execution time: 732 nanoseconds. + Weight::from_ref_time(1_134_852 as u64) + // Standard Error: 289 + .saturating_add(Weight::from_ref_time(844_232 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 718 nanoseconds. - Weight::from_ref_time(991_713 as u64) - // Standard Error: 376 - .saturating_add(Weight::from_ref_time(958_921 as u64).saturating_mul(r as u64)) + // Minimum execution time: 732 nanoseconds. + Weight::from_ref_time(1_101_513 as u64) + // Standard Error: 404 + .saturating_add(Weight::from_ref_time(853_552 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 737 nanoseconds. - Weight::from_ref_time(1_003_536 as u64) - // Standard Error: 357 - .saturating_add(Weight::from_ref_time(753_905 as u64).saturating_mul(r as u64)) + // Minimum execution time: 773 nanoseconds. + Weight::from_ref_time(1_028_022 as u64) + // Standard Error: 300 + .saturating_add(Weight::from_ref_time(735_549 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(720_128 as u64) - // Standard Error: 3_756 - .saturating_add(Weight::from_ref_time(188_693_871 as u64).saturating_mul(r as u64)) + // Minimum execution time: 685 nanoseconds. + Weight::from_ref_time(767_438 as u64) + // Standard Error: 5_152 + .saturating_add(Weight::from_ref_time(184_668_261 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(892_350 as u64) - // Standard Error: 221 - .saturating_add(Weight::from_ref_time(672_006 as u64).saturating_mul(r as u64)) + // Minimum execution time: 679 nanoseconds. + Weight::from_ref_time(988_596 as u64) + // Standard Error: 356 + .saturating_add(Weight::from_ref_time(671_490 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 652 nanoseconds. - Weight::from_ref_time(921_248 as u64) - // Standard Error: 298 - .saturating_add(Weight::from_ref_time(671_631 as u64).saturating_mul(r as u64)) + // Minimum execution time: 644 nanoseconds. + Weight::from_ref_time(967_209 as u64) + // Standard Error: 266 + .saturating_add(Weight::from_ref_time(671_486 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 645 nanoseconds. - Weight::from_ref_time(890_444 as u64) - // Standard Error: 247 - .saturating_add(Weight::from_ref_time(672_057 as u64).saturating_mul(r as u64)) + // Minimum execution time: 675 nanoseconds. + Weight::from_ref_time(957_638 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(671_491 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 684 nanoseconds. - Weight::from_ref_time(910_228 as u64) - // Standard Error: 171 - .saturating_add(Weight::from_ref_time(684_713 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(955_424 as u64) + // Standard Error: 203 + .saturating_add(Weight::from_ref_time(679_485 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 668 nanoseconds. - Weight::from_ref_time(874_456 as u64) - // Standard Error: 171 - .saturating_add(Weight::from_ref_time(671_242 as u64).saturating_mul(r as u64)) + // Minimum execution time: 697 nanoseconds. + Weight::from_ref_time(984_180 as u64) + // Standard Error: 229 + .saturating_add(Weight::from_ref_time(669_999 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 632 nanoseconds. - Weight::from_ref_time(900_807 as u64) - // Standard Error: 235 - .saturating_add(Weight::from_ref_time(670_298 as u64).saturating_mul(r as u64)) + // Minimum execution time: 684 nanoseconds. + Weight::from_ref_time(953_264 as u64) + // Standard Error: 236 + .saturating_add(Weight::from_ref_time(670_453 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 647 nanoseconds. - Weight::from_ref_time(910_984 as u64) - // Standard Error: 327 - .saturating_add(Weight::from_ref_time(671_129 as u64).saturating_mul(r as u64)) + // Minimum execution time: 688 nanoseconds. + Weight::from_ref_time(929_692 as u64) + // Standard Error: 329 + .saturating_add(Weight::from_ref_time(671_908 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 658 nanoseconds. - Weight::from_ref_time(895_986 as u64) - // Standard Error: 565 - .saturating_add(Weight::from_ref_time(913_649 as u64).saturating_mul(r as u64)) + // Minimum execution time: 639 nanoseconds. + Weight::from_ref_time(969_783 as u64) + // Standard Error: 264 + .saturating_add(Weight::from_ref_time(911_639 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 671 nanoseconds. - Weight::from_ref_time(892_539 as u64) - // Standard Error: 202 - .saturating_add(Weight::from_ref_time(913_503 as u64).saturating_mul(r as u64)) + // Minimum execution time: 691 nanoseconds. + Weight::from_ref_time(971_680 as u64) + // Standard Error: 321 + .saturating_add(Weight::from_ref_time(912_755 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 655 nanoseconds. - Weight::from_ref_time(960_186 as u64) - // Standard Error: 472 - .saturating_add(Weight::from_ref_time(922_417 as u64).saturating_mul(r as u64)) + // Minimum execution time: 669 nanoseconds. + Weight::from_ref_time(971_262 as u64) + // Standard Error: 225 + .saturating_add(Weight::from_ref_time(922_734 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 635 nanoseconds. - Weight::from_ref_time(870_482 as u64) - // Standard Error: 274 - .saturating_add(Weight::from_ref_time(914_130 as u64).saturating_mul(r as u64)) + // Minimum execution time: 654 nanoseconds. + Weight::from_ref_time(1_098_940 as u64) + // Standard Error: 944 + .saturating_add(Weight::from_ref_time(908_472 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 621 nanoseconds. - Weight::from_ref_time(891_451 as u64) - // Standard Error: 247 - .saturating_add(Weight::from_ref_time(909_133 as u64).saturating_mul(r as u64)) + // Minimum execution time: 729 nanoseconds. + Weight::from_ref_time(964_462 as u64) + // Standard Error: 256 + .saturating_add(Weight::from_ref_time(908_072 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 662 nanoseconds. - Weight::from_ref_time(904_400 as u64) - // Standard Error: 194 - .saturating_add(Weight::from_ref_time(917_254 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(948_256 as u64) + // Standard Error: 565 + .saturating_add(Weight::from_ref_time(920_128 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 673 nanoseconds. - Weight::from_ref_time(913_787 as u64) - // Standard Error: 185 - .saturating_add(Weight::from_ref_time(911_025 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(968_099 as u64) + // Standard Error: 368 + .saturating_add(Weight::from_ref_time(910_690 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(892_985 as u64) - // Standard Error: 175 - .saturating_add(Weight::from_ref_time(919_451 as u64).saturating_mul(r as u64)) + // Minimum execution time: 662 nanoseconds. + Weight::from_ref_time(972_425 as u64) + // Standard Error: 697 + .saturating_add(Weight::from_ref_time(922_352 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 666 nanoseconds. - Weight::from_ref_time(907_510 as u64) - // Standard Error: 204 - .saturating_add(Weight::from_ref_time(911_125 as u64).saturating_mul(r as u64)) + // Minimum execution time: 648 nanoseconds. + Weight::from_ref_time(949_113 as u64) + // Standard Error: 297 + .saturating_add(Weight::from_ref_time(912_150 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(896_012 as u64) - // Standard Error: 262 - .saturating_add(Weight::from_ref_time(911_762 as u64).saturating_mul(r as u64)) + // Minimum execution time: 673 nanoseconds. + Weight::from_ref_time(987_094 as u64) + // Standard Error: 301 + .saturating_add(Weight::from_ref_time(911_257 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 653 nanoseconds. - Weight::from_ref_time(921_793 as u64) - // Standard Error: 220 - .saturating_add(Weight::from_ref_time(900_803 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(981_475 as u64) + // Standard Error: 374 + .saturating_add(Weight::from_ref_time(901_865 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 676 nanoseconds. - Weight::from_ref_time(908_870 as u64) - // Standard Error: 277 - .saturating_add(Weight::from_ref_time(897_408 as u64).saturating_mul(r as u64)) + // Minimum execution time: 668 nanoseconds. + Weight::from_ref_time(965_213 as u64) + // Standard Error: 303 + .saturating_add(Weight::from_ref_time(896_888 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 671 nanoseconds. - Weight::from_ref_time(806_379 as u64) - // Standard Error: 638 - .saturating_add(Weight::from_ref_time(911_294 as u64).saturating_mul(r as u64)) + // Minimum execution time: 652 nanoseconds. + Weight::from_ref_time(980_542 as u64) + // Standard Error: 299 + .saturating_add(Weight::from_ref_time(905_822 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 639 nanoseconds. - Weight::from_ref_time(679_032 as u64) - // Standard Error: 6_536 - .saturating_add(Weight::from_ref_time(1_512_247 as u64).saturating_mul(r as u64)) + // Minimum execution time: 684 nanoseconds. + Weight::from_ref_time(925_256 as u64) + // Standard Error: 433 + .saturating_add(Weight::from_ref_time(1_499_876 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 653 nanoseconds. - Weight::from_ref_time(864_336 as u64) - // Standard Error: 251 - .saturating_add(Weight::from_ref_time(1_361_436 as u64).saturating_mul(r as u64)) + // Minimum execution time: 682 nanoseconds. + Weight::from_ref_time(967_909 as u64) + // Standard Error: 378 + .saturating_add(Weight::from_ref_time(1_363_274 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(969_193 as u64) - // Standard Error: 333 - .saturating_add(Weight::from_ref_time(1_521_975 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(983_259 as u64) + // Standard Error: 430 + .saturating_add(Weight::from_ref_time(1_526_000 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(869_301 as u64) - // Standard Error: 177 - .saturating_add(Weight::from_ref_time(1_361_528 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(933_173 as u64) + // Standard Error: 485 + .saturating_add(Weight::from_ref_time(1_364_737 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 626 nanoseconds. - Weight::from_ref_time(883_738 as u64) - // Standard Error: 288 - .saturating_add(Weight::from_ref_time(901_730 as u64).saturating_mul(r as u64)) + // Minimum execution time: 668 nanoseconds. + Weight::from_ref_time(874_117 as u64) + // Standard Error: 1_179 + .saturating_add(Weight::from_ref_time(908_945 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 637 nanoseconds. - Weight::from_ref_time(892_052 as u64) - // Standard Error: 297 - .saturating_add(Weight::from_ref_time(901_479 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(956_367 as u64) + // Standard Error: 470 + .saturating_add(Weight::from_ref_time(903_366 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 617 nanoseconds. - Weight::from_ref_time(882_714 as u64) - // Standard Error: 207 - .saturating_add(Weight::from_ref_time(901_984 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(957_477 as u64) + // Standard Error: 348 + .saturating_add(Weight::from_ref_time(902_774 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(885_605 as u64) - // Standard Error: 329 - .saturating_add(Weight::from_ref_time(911_644 as u64).saturating_mul(r as u64)) + // Minimum execution time: 666 nanoseconds. + Weight::from_ref_time(1_039_773 as u64) + // Standard Error: 409 + .saturating_add(Weight::from_ref_time(908_871 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 655 nanoseconds. - Weight::from_ref_time(916_923 as u64) - // Standard Error: 219 - .saturating_add(Weight::from_ref_time(910_766 as u64).saturating_mul(r as u64)) + // Minimum execution time: 659 nanoseconds. + Weight::from_ref_time(950_752 as u64) + // Standard Error: 398 + .saturating_add(Weight::from_ref_time(910_881 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 688 nanoseconds. - Weight::from_ref_time(890_697 as u64) - // Standard Error: 224 - .saturating_add(Weight::from_ref_time(910_605 as u64).saturating_mul(r as u64)) + // Minimum execution time: 677 nanoseconds. + Weight::from_ref_time(983_624 as u64) + // Standard Error: 286 + .saturating_add(Weight::from_ref_time(914_185 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 679 nanoseconds. - Weight::from_ref_time(964_104 as u64) - // Standard Error: 658 - .saturating_add(Weight::from_ref_time(908_547 as u64).saturating_mul(r as u64)) + // Minimum execution time: 652 nanoseconds. + Weight::from_ref_time(991_102 as u64) + // Standard Error: 316 + .saturating_add(Weight::from_ref_time(910_114 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 629 nanoseconds. - Weight::from_ref_time(879_488 as u64) - // Standard Error: 195 - .saturating_add(Weight::from_ref_time(910_911 as u64).saturating_mul(r as u64)) + // Minimum execution time: 664 nanoseconds. + Weight::from_ref_time(1_017_602 as u64) + // Standard Error: 965 + .saturating_add(Weight::from_ref_time(909_533 as u64).saturating_mul(r as u64)) } } @@ -1384,17 +1384,17 @@ impl WeightInfo for SubstrateWeight { impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 2_919 nanoseconds. - Weight::from_ref_time(3_033_000 as u64) + // Minimum execution time: 2_931 nanoseconds. + Weight::from_ref_time(3_115_000 as u64) .saturating_add(RocksDbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 14_627 nanoseconds. - Weight::from_ref_time(16_018_897 as u64) - // Standard Error: 824 - .saturating_add(Weight::from_ref_time(893_332 as u64).saturating_mul(k as u64)) + // Minimum execution time: 15_035 nanoseconds. + Weight::from_ref_time(15_007_164 as u64) + // Standard Error: 986 + .saturating_add(Weight::from_ref_time(900_803 as u64).saturating_mul(k as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) .saturating_add(RocksDbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -1402,10 +1402,10 @@ impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 2_867 nanoseconds. - Weight::from_ref_time(13_411_793 as u64) - // Standard Error: 5_268 - .saturating_add(Weight::from_ref_time(1_244_288 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_060 nanoseconds. + Weight::from_ref_time(15_200_003 as u64) + // Standard Error: 3_323 + .saturating_add(Weight::from_ref_time(1_244_355 as u64).saturating_mul(q as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1413,10 +1413,10 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 20_987 nanoseconds. - Weight::from_ref_time(24_245_898 as u64) - // Standard Error: 48 - .saturating_add(Weight::from_ref_time(34_792 as u64).saturating_mul(c as u64)) + // Minimum execution time: 28_377 nanoseconds. + Weight::from_ref_time(20_120_669 as u64) + // Standard Error: 60 + .saturating_add(Weight::from_ref_time(49_221 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1427,10 +1427,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 299_074 nanoseconds. - Weight::from_ref_time(306_372_889 as u64) - // Standard Error: 25 - .saturating_add(Weight::from_ref_time(30_663 as u64).saturating_mul(c as u64)) + // Minimum execution time: 293_993 nanoseconds. + Weight::from_ref_time(313_583_072 as u64) + // Standard Error: 23 + .saturating_add(Weight::from_ref_time(30_370 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1445,12 +1445,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_072_174 nanoseconds. - Weight::from_ref_time(337_874_723 as u64) - // Standard Error: 73 - .saturating_add(Weight::from_ref_time(88_343 as u64).saturating_mul(c as u64)) + // Minimum execution time: 2_076_093 nanoseconds. + Weight::from_ref_time(317_276_951 as u64) + // Standard Error: 70 + .saturating_add(Weight::from_ref_time(92_182 as u64).saturating_mul(c as u64)) // Standard Error: 4 - .saturating_add(Weight::from_ref_time(1_695 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_719 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(9 as u64)) } @@ -1463,10 +1463,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 178_787 nanoseconds. - Weight::from_ref_time(171_072_954 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_447 as u64).saturating_mul(s as u64)) + // Minimum execution time: 179_314 nanoseconds. + Weight::from_ref_time(172_604_510 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_451 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(7 as u64)) } @@ -1476,8 +1476,8 @@ impl WeightInfo for () { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 147_880 nanoseconds. - Weight::from_ref_time(149_054_000 as u64) + // Minimum execution time: 147_799 nanoseconds. + Weight::from_ref_time(149_370_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1487,10 +1487,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 281_951 nanoseconds. - Weight::from_ref_time(296_591_045 as u64) - // Standard Error: 59 - .saturating_add(Weight::from_ref_time(75_741 as u64).saturating_mul(c as u64)) + // Minimum execution time: 282_031 nanoseconds. + Weight::from_ref_time(298_764_288 as u64) + // Standard Error: 64 + .saturating_add(Weight::from_ref_time(79_500 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1499,8 +1499,8 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 38_314 nanoseconds. - Weight::from_ref_time(39_208_000 as u64) + // Minimum execution time: 39_154 nanoseconds. + Weight::from_ref_time(39_913_000 as u64) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1508,8 +1508,8 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 40_821 nanoseconds. - Weight::from_ref_time(41_085_000 as u64) + // Minimum execution time: 40_761 nanoseconds. + Weight::from_ref_time(41_352_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(6 as u64)) } @@ -1520,10 +1520,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 283_566 nanoseconds. - Weight::from_ref_time(291_662_997 as u64) - // Standard Error: 26_198 - .saturating_add(Weight::from_ref_time(15_812_705 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_740 nanoseconds. + Weight::from_ref_time(291_554_435 as u64) + // Standard Error: 37_422 + .saturating_add(Weight::from_ref_time(15_763_400 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1534,10 +1534,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 283_050 nanoseconds. - Weight::from_ref_time(231_589_172 as u64) - // Standard Error: 457_107 - .saturating_add(Weight::from_ref_time(194_493_604 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_398 nanoseconds. + Weight::from_ref_time(227_488_874 as u64) + // Standard Error: 475_749 + .saturating_add(Weight::from_ref_time(191_273_619 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1549,10 +1549,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 289_561 nanoseconds. - Weight::from_ref_time(241_544_282 as u64) - // Standard Error: 439_485 - .saturating_add(Weight::from_ref_time(234_068_306 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_004 nanoseconds. + Weight::from_ref_time(240_522_081 as u64) + // Standard Error: 465_475 + .saturating_add(Weight::from_ref_time(233_370_074 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1564,10 +1564,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 284_800 nanoseconds. - Weight::from_ref_time(292_300_021 as u64) - // Standard Error: 40_833 - .saturating_add(Weight::from_ref_time(19_473_073 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_980 nanoseconds. + Weight::from_ref_time(293_143_705 as u64) + // Standard Error: 31_246 + .saturating_add(Weight::from_ref_time(19_336_451 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1578,10 +1578,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 286_811 nanoseconds. - Weight::from_ref_time(289_605_062 as u64) - // Standard Error: 17_481 - .saturating_add(Weight::from_ref_time(11_088_146 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_954 nanoseconds. + Weight::from_ref_time(290_721_695 as u64) + // Standard Error: 18_098 + .saturating_add(Weight::from_ref_time(10_760_625 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1592,10 +1592,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 284_389 nanoseconds. - Weight::from_ref_time(291_607_958 as u64) - // Standard Error: 33_895 - .saturating_add(Weight::from_ref_time(15_781_940 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_009 nanoseconds. + Weight::from_ref_time(290_691_942 as u64) + // Standard Error: 31_912 + .saturating_add(Weight::from_ref_time(15_739_831 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1606,10 +1606,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 282_896 nanoseconds. - Weight::from_ref_time(289_802_376 as u64) - // Standard Error: 33_013 - .saturating_add(Weight::from_ref_time(15_705_525 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_020 nanoseconds. + Weight::from_ref_time(290_217_625 as u64) + // Standard Error: 32_889 + .saturating_add(Weight::from_ref_time(15_564_753 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1620,10 +1620,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 284_380 nanoseconds. - Weight::from_ref_time(291_136_750 as u64) - // Standard Error: 92_026 - .saturating_add(Weight::from_ref_time(86_938_178 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_291 nanoseconds. + Weight::from_ref_time(300_497_640 as u64) + // Standard Error: 81_211 + .saturating_add(Weight::from_ref_time(88_485_235 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1634,10 +1634,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 286_734 nanoseconds. - Weight::from_ref_time(290_556_604 as u64) - // Standard Error: 31_726 - .saturating_add(Weight::from_ref_time(15_580_656 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_704 nanoseconds. + Weight::from_ref_time(289_980_711 as u64) + // Standard Error: 19_233 + .saturating_add(Weight::from_ref_time(15_794_847 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1648,10 +1648,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 282_935 nanoseconds. - Weight::from_ref_time(290_693_236 as u64) - // Standard Error: 24_862 - .saturating_add(Weight::from_ref_time(15_421_306 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_969 nanoseconds. + Weight::from_ref_time(289_628_583 as u64) + // Standard Error: 31_071 + .saturating_add(Weight::from_ref_time(15_512_708 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1662,10 +1662,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 287_010 nanoseconds. - Weight::from_ref_time(290_738_164 as u64) - // Standard Error: 20_205 - .saturating_add(Weight::from_ref_time(15_237_554 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_738 nanoseconds. + Weight::from_ref_time(290_782_451 as u64) + // Standard Error: 28_491 + .saturating_add(Weight::from_ref_time(15_480_085 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1676,10 +1676,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 286_862 nanoseconds. - Weight::from_ref_time(291_029_188 as u64) - // Standard Error: 30_491 - .saturating_add(Weight::from_ref_time(15_450_941 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_761 nanoseconds. + Weight::from_ref_time(291_086_703 as u64) + // Standard Error: 25_134 + .saturating_add(Weight::from_ref_time(15_389_582 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1691,10 +1691,10 @@ impl WeightInfo for () { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 283_725 nanoseconds. - Weight::from_ref_time(293_071_360 as u64) - // Standard Error: 97_620 - .saturating_add(Weight::from_ref_time(85_454_560 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_456 nanoseconds. + Weight::from_ref_time(293_334_784 as u64) + // Standard Error: 84_335 + .saturating_add(Weight::from_ref_time(87_972_926 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1705,10 +1705,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 135_545 nanoseconds. - Weight::from_ref_time(139_022_047 as u64) - // Standard Error: 9_547 - .saturating_add(Weight::from_ref_time(7_859_219 as u64).saturating_mul(r as u64)) + // Minimum execution time: 135_621 nanoseconds. + Weight::from_ref_time(138_776_095 as u64) + // Standard Error: 9_723 + .saturating_add(Weight::from_ref_time(7_833_191 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1719,10 +1719,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 283_396 nanoseconds. - Weight::from_ref_time(291_462_361 as u64) - // Standard Error: 28_397 - .saturating_add(Weight::from_ref_time(13_492_690 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_231 nanoseconds. + Weight::from_ref_time(290_476_129 as u64) + // Standard Error: 21_078 + .saturating_add(Weight::from_ref_time(13_426_746 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1733,10 +1733,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 302_871 nanoseconds. - Weight::from_ref_time(320_897_273 as u64) - // Standard Error: 3_496 - .saturating_add(Weight::from_ref_time(9_614_024 as u64).saturating_mul(n as u64)) + // Minimum execution time: 298_683 nanoseconds. + Weight::from_ref_time(324_926_199 as u64) + // Standard Error: 3_973 + .saturating_add(Weight::from_ref_time(9_603_913 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1747,10 +1747,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 280_519 nanoseconds. - Weight::from_ref_time(286_177_785 as u64) - // Standard Error: 101_357 - .saturating_add(Weight::from_ref_time(888_714 as u64).saturating_mul(r as u64)) + // Minimum execution time: 277_985 nanoseconds. + Weight::from_ref_time(286_423_097 as u64) + // Standard Error: 130_406 + .saturating_add(Weight::from_ref_time(891_202 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1761,10 +1761,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 285_901 nanoseconds. - Weight::from_ref_time(287_315_127 as u64) - // Standard Error: 877 - .saturating_add(Weight::from_ref_time(190_891 as u64).saturating_mul(n as u64)) + // Minimum execution time: 283_769 nanoseconds. + Weight::from_ref_time(287_958_946 as u64) + // Standard Error: 668 + .saturating_add(Weight::from_ref_time(187_637 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1777,10 +1777,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 282_147 nanoseconds. - Weight::from_ref_time(287_753_920 as u64) - // Standard Error: 99_065 - .saturating_add(Weight::from_ref_time(53_786_379 as u64).saturating_mul(r as u64)) + // Minimum execution time: 278_534 nanoseconds. + Weight::from_ref_time(287_780_036 as u64) + // Standard Error: 129_466 + .saturating_add(Weight::from_ref_time(53_007_763 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1794,10 +1794,10 @@ impl WeightInfo for () { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 282_779 nanoseconds. - Weight::from_ref_time(295_701_851 as u64) - // Standard Error: 92_851 - .saturating_add(Weight::from_ref_time(106_176_241 as u64).saturating_mul(r as u64)) + // Minimum execution time: 278_493 nanoseconds. + Weight::from_ref_time(290_592_257 as u64) + // Standard Error: 94_173 + .saturating_add(Weight::from_ref_time(107_930_905 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1808,10 +1808,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 281_392 nanoseconds. - Weight::from_ref_time(296_151_487 as u64) - // Standard Error: 117_012 - .saturating_add(Weight::from_ref_time(222_546_893 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_247 nanoseconds. + Weight::from_ref_time(296_142_593 as u64) + // Standard Error: 96_546 + .saturating_add(Weight::from_ref_time(218_331_111 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1823,12 +1823,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_192_807 nanoseconds. - Weight::from_ref_time(506_881_525 as u64) - // Standard Error: 443_155 - .saturating_add(Weight::from_ref_time(177_724_866 as u64).saturating_mul(t as u64)) - // Standard Error: 121_711 - .saturating_add(Weight::from_ref_time(67_213_725 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_180_712 nanoseconds. + Weight::from_ref_time(493_002_751 as u64) + // Standard Error: 533_813 + .saturating_add(Weight::from_ref_time(177_505_380 as u64).saturating_mul(t as u64)) + // Standard Error: 146_611 + .saturating_add(Weight::from_ref_time(67_941_198 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1841,20 +1841,20 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 148_269 nanoseconds. - Weight::from_ref_time(152_128_988 as u64) - // Standard Error: 16_981 - .saturating_add(Weight::from_ref_time(12_691_070 as u64).saturating_mul(r as u64)) + // Minimum execution time: 148_732 nanoseconds. + Weight::from_ref_time(152_227_471 as u64) + // Standard Error: 19_202 + .saturating_add(Weight::from_ref_time(12_568_111 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 284_194 nanoseconds. - Weight::from_ref_time(249_462_948 as u64) - // Standard Error: 420_603 - .saturating_add(Weight::from_ref_time(382_005_385 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_482 nanoseconds. + Weight::from_ref_time(243_156_068 as u64) + // Standard Error: 474_497 + .saturating_add(Weight::from_ref_time(388_742_860 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1863,10 +1863,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 416_372 nanoseconds. - Weight::from_ref_time(558_600_043 as u64) - // Standard Error: 1_283_845 - .saturating_add(Weight::from_ref_time(87_356_639 as u64).saturating_mul(n as u64)) + // Minimum execution time: 414_293 nanoseconds. + Weight::from_ref_time(559_267_738 as u64) + // Standard Error: 1_303_216 + .saturating_add(Weight::from_ref_time(90_036_803 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(52 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(50 as u64)) @@ -1875,10 +1875,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 414_605 nanoseconds. - Weight::from_ref_time(531_590_681 as u64) - // Standard Error: 1_081_636 - .saturating_add(Weight::from_ref_time(61_988_451 as u64).saturating_mul(n as u64)) + // Minimum execution time: 414_033 nanoseconds. + Weight::from_ref_time(532_231_525 as u64) + // Standard Error: 1_055_953 + .saturating_add(Weight::from_ref_time(62_435_646 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(49 as u64)) @@ -1887,10 +1887,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 284_561 nanoseconds. - Weight::from_ref_time(247_133_699 as u64) - // Standard Error: 430_882 - .saturating_add(Weight::from_ref_time(380_288_678 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_504 nanoseconds. + Weight::from_ref_time(246_435_673 as u64) + // Standard Error: 453_053 + .saturating_add(Weight::from_ref_time(380_783_741 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1899,10 +1899,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 385_375 nanoseconds. - Weight::from_ref_time(515_998_814 as u64) - // Standard Error: 1_205_946 - .saturating_add(Weight::from_ref_time(63_741_054 as u64).saturating_mul(n as u64)) + // Minimum execution time: 382_408 nanoseconds. + Weight::from_ref_time(512_746_664 as u64) + // Standard Error: 1_172_067 + .saturating_add(Weight::from_ref_time(65_032_243 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -1911,10 +1911,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 284_047 nanoseconds. - Weight::from_ref_time(258_952_780 as u64) - // Standard Error: 359_810 - .saturating_add(Weight::from_ref_time(299_965_622 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_790 nanoseconds. + Weight::from_ref_time(257_076_625 as u64) + // Standard Error: 403_694 + .saturating_add(Weight::from_ref_time(302_599_469 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1922,10 +1922,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 364_719 nanoseconds. - Weight::from_ref_time(479_168_397 as u64) - // Standard Error: 1_056_296 - .saturating_add(Weight::from_ref_time(148_008_433 as u64).saturating_mul(n as u64)) + // Minimum execution time: 360_774 nanoseconds. + Weight::from_ref_time(477_765_083 as u64) + // Standard Error: 1_054_248 + .saturating_add(Weight::from_ref_time(149_132_576 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1933,10 +1933,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 285_860 nanoseconds. - Weight::from_ref_time(260_444_355 as u64) - // Standard Error: 354_017 - .saturating_add(Weight::from_ref_time(285_201_666 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_275 nanoseconds. + Weight::from_ref_time(257_256_687 as u64) + // Standard Error: 390_455 + .saturating_add(Weight::from_ref_time(288_646_973 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1944,10 +1944,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 359_457 nanoseconds. - Weight::from_ref_time(459_211_204 as u64) - // Standard Error: 912_412 - .saturating_add(Weight::from_ref_time(56_532_346 as u64).saturating_mul(n as u64)) + // Minimum execution time: 359_931 nanoseconds. + Weight::from_ref_time(458_152_093 as u64) + // Standard Error: 892_824 + .saturating_add(Weight::from_ref_time(57_758_562 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1955,10 +1955,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 285_064 nanoseconds. - Weight::from_ref_time(246_043_797 as u64) - // Standard Error: 442_983 - .saturating_add(Weight::from_ref_time(392_246_113 as u64).saturating_mul(r as u64)) + // Minimum execution time: 281_231 nanoseconds. + Weight::from_ref_time(244_165_075 as u64) + // Standard Error: 473_122 + .saturating_add(Weight::from_ref_time(393_316_438 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1967,10 +1967,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 387_629 nanoseconds. - Weight::from_ref_time(529_491_574 as u64) - // Standard Error: 1_311_955 - .saturating_add(Weight::from_ref_time(155_160_167 as u64).saturating_mul(n as u64)) + // Minimum execution time: 387_247 nanoseconds. + Weight::from_ref_time(531_048_473 as u64) + // Standard Error: 1_295_482 + .saturating_add(Weight::from_ref_time(155_055_305 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -1983,10 +1983,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 287_827 nanoseconds. - Weight::from_ref_time(226_727_998 as u64) - // Standard Error: 758_553 - .saturating_add(Weight::from_ref_time(1_311_899_729 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_950 nanoseconds. + Weight::from_ref_time(247_687_017 as u64) + // Standard Error: 701_992 + .saturating_add(Weight::from_ref_time(1_334_157_964 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(4 as u64)) @@ -1999,10 +1999,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 286_474 nanoseconds. - Weight::from_ref_time(290_308_000 as u64) - // Standard Error: 6_440_996 - .saturating_add(Weight::from_ref_time(20_239_024_486 as u64).saturating_mul(r as u64)) + // Minimum execution time: 282_248 nanoseconds. + Weight::from_ref_time(289_718_000 as u64) + // Standard Error: 6_905_454 + .saturating_add(Weight::from_ref_time(20_181_920_493 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2015,10 +2015,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 288_054 nanoseconds. - Weight::from_ref_time(290_468_000 as u64) - // Standard Error: 6_594_354 - .saturating_add(Weight::from_ref_time(20_004_202_621 as u64).saturating_mul(r as u64)) + // Minimum execution time: 283_335 nanoseconds. + Weight::from_ref_time(290_342_000 as u64) + // Standard Error: 6_735_691 + .saturating_add(Weight::from_ref_time(19_874_310_103 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2032,12 +2032,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 9_023_111 nanoseconds. - Weight::from_ref_time(8_008_697_453 as u64) - // Standard Error: 6_164_150 - .saturating_add(Weight::from_ref_time(1_242_557_423 as u64).saturating_mul(t as u64)) - // Standard Error: 9_242 - .saturating_add(Weight::from_ref_time(9_790_280 as u64).saturating_mul(c as u64)) + // Minimum execution time: 8_973_394 nanoseconds. + Weight::from_ref_time(7_928_586_368 as u64) + // Standard Error: 6_427_011 + .saturating_add(Weight::from_ref_time(1_276_828_100 as u64).saturating_mul(t as u64)) + // Standard Error: 9_636 + .saturating_add(Weight::from_ref_time(9_833_968 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(167 as u64)) .saturating_add(RocksDbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(163 as u64)) @@ -2052,10 +2052,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 286_837 nanoseconds. - Weight::from_ref_time(291_218_000 as u64) - // Standard Error: 19_786_457 - .saturating_add(Weight::from_ref_time(25_510_029_458 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_929 nanoseconds. + Weight::from_ref_time(289_843_000 as u64) + // Standard Error: 20_434_247 + .saturating_add(Weight::from_ref_time(25_448_464_329 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(5 as u64)) @@ -2071,10 +2071,10 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 11_068_335 nanoseconds. - Weight::from_ref_time(10_796_296_013 as u64) - // Standard Error: 76_863 - .saturating_add(Weight::from_ref_time(119_227_442 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_073_432 nanoseconds. + Weight::from_ref_time(10_946_295_951 as u64) + // Standard Error: 81_481 + .saturating_add(Weight::from_ref_time(119_266_558 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(249 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(247 as u64)) @@ -2087,10 +2087,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 283_120 nanoseconds. - Weight::from_ref_time(289_308_957 as u64) - // Standard Error: 166_497 - .saturating_add(Weight::from_ref_time(41_451_242 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_830 nanoseconds. + Weight::from_ref_time(290_209_802 as u64) + // Standard Error: 169_549 + .saturating_add(Weight::from_ref_time(43_035_497 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2101,10 +2101,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 329_812 nanoseconds. - Weight::from_ref_time(330_612_000 as u64) - // Standard Error: 53_026 - .saturating_add(Weight::from_ref_time(322_254_314 as u64).saturating_mul(n as u64)) + // Minimum execution time: 328_452 nanoseconds. + Weight::from_ref_time(331_955_000 as u64) + // Standard Error: 48_357 + .saturating_add(Weight::from_ref_time(322_126_385 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2115,10 +2115,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 283_513 nanoseconds. - Weight::from_ref_time(288_770_253 as u64) - // Standard Error: 127_481 - .saturating_add(Weight::from_ref_time(54_024_646 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_512 nanoseconds. + Weight::from_ref_time(289_141_330 as u64) + // Standard Error: 139_948 + .saturating_add(Weight::from_ref_time(53_676_369 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2129,10 +2129,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 337_526 nanoseconds. - Weight::from_ref_time(341_798_000 as u64) - // Standard Error: 55_732 - .saturating_add(Weight::from_ref_time(246_278_245 as u64).saturating_mul(n as u64)) + // Minimum execution time: 337_000 nanoseconds. + Weight::from_ref_time(341_992_000 as u64) + // Standard Error: 63_898 + .saturating_add(Weight::from_ref_time(246_190_881 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2143,10 +2143,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 282_755 nanoseconds. - Weight::from_ref_time(288_770_457 as u64) - // Standard Error: 126_198 - .saturating_add(Weight::from_ref_time(31_005_842 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_082 nanoseconds. + Weight::from_ref_time(289_205_383 as u64) + // Standard Error: 147_477 + .saturating_add(Weight::from_ref_time(31_447_316 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2157,10 +2157,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 318_456 nanoseconds. - Weight::from_ref_time(319_657_000 as u64) - // Standard Error: 48_627 - .saturating_add(Weight::from_ref_time(96_235_891 as u64).saturating_mul(n as u64)) + // Minimum execution time: 317_203 nanoseconds. + Weight::from_ref_time(320_227_000 as u64) + // Standard Error: 60_664 + .saturating_add(Weight::from_ref_time(96_574_720 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2171,10 +2171,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 279_514 nanoseconds. - Weight::from_ref_time(286_965_600 as u64) - // Standard Error: 139_737 - .saturating_add(Weight::from_ref_time(31_455_000 as u64).saturating_mul(r as u64)) + // Minimum execution time: 279_129 nanoseconds. + Weight::from_ref_time(287_316_563 as u64) + // Standard Error: 344_649 + .saturating_add(Weight::from_ref_time(36_089_836 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2185,10 +2185,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 314_440 nanoseconds. - Weight::from_ref_time(317_795_000 as u64) - // Standard Error: 50_822 - .saturating_add(Weight::from_ref_time(96_256_697 as u64).saturating_mul(n as u64)) + // Minimum execution time: 313_600 nanoseconds. + Weight::from_ref_time(318_372_000 as u64) + // Standard Error: 60_022 + .saturating_add(Weight::from_ref_time(96_662_276 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2199,10 +2199,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 283_599 nanoseconds. - Weight::from_ref_time(289_683_557 as u64) - // Standard Error: 536_607 - .saturating_add(Weight::from_ref_time(3_008_499_142 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_253 nanoseconds. + Weight::from_ref_time(289_841_369 as u64) + // Standard Error: 720_896 + .saturating_add(Weight::from_ref_time(3_014_326_830 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2213,10 +2213,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 283_690 nanoseconds. - Weight::from_ref_time(289_027_440 as u64) - // Standard Error: 371_475 - .saturating_add(Weight::from_ref_time(2_049_105_659 as u64).saturating_mul(r as u64)) + // Minimum execution time: 280_063 nanoseconds. + Weight::from_ref_time(289_066_912 as u64) + // Standard Error: 444_023 + .saturating_add(Weight::from_ref_time(2_044_352_087 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2228,10 +2228,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 283_919 nanoseconds. - Weight::from_ref_time(288_356_000 as u64) - // Standard Error: 2_749_310 - .saturating_add(Weight::from_ref_time(1_358_240_619 as u64).saturating_mul(r as u64)) + // Minimum execution time: 284_089 nanoseconds. + Weight::from_ref_time(286_104_000 as u64) + // Standard Error: 2_723_838 + .saturating_add(Weight::from_ref_time(1_364_603_517 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2239,359 +2239,359 @@ impl WeightInfo for () { } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 633 nanoseconds. - Weight::from_ref_time(833_605 as u64) - // Standard Error: 256 - .saturating_add(Weight::from_ref_time(493_683 as u64).saturating_mul(r as u64)) + // Minimum execution time: 710 nanoseconds. + Weight::from_ref_time(923_784 as u64) + // Standard Error: 272 + .saturating_add(Weight::from_ref_time(493_874 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 772 nanoseconds. - Weight::from_ref_time(1_216_335 as u64) - // Standard Error: 506 - .saturating_add(Weight::from_ref_time(1_100_153 as u64).saturating_mul(r as u64)) + // Minimum execution time: 781 nanoseconds. + Weight::from_ref_time(1_275_543 as u64) + // Standard Error: 1_135 + .saturating_add(Weight::from_ref_time(1_111_569 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 752 nanoseconds. - Weight::from_ref_time(1_232_818 as u64) - // Standard Error: 509 - .saturating_add(Weight::from_ref_time(1_006_310 as u64).saturating_mul(r as u64)) + // Minimum execution time: 786 nanoseconds. + Weight::from_ref_time(1_145_302 as u64) + // Standard Error: 972 + .saturating_add(Weight::from_ref_time(1_020_583 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 636 nanoseconds. - Weight::from_ref_time(908_576 as u64) - // Standard Error: 223 - .saturating_add(Weight::from_ref_time(1_183_249 as u64).saturating_mul(r as u64)) + // Minimum execution time: 647 nanoseconds. + Weight::from_ref_time(976_972 as u64) + // Standard Error: 331 + .saturating_add(Weight::from_ref_time(1_187_260 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 654 nanoseconds. - Weight::from_ref_time(668_211 as u64) - // Standard Error: 1_202 - .saturating_add(Weight::from_ref_time(1_518_771 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(686_941 as u64) + // Standard Error: 450 + .saturating_add(Weight::from_ref_time(1_530_719 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 660 nanoseconds. - Weight::from_ref_time(859_213 as u64) - // Standard Error: 243 - .saturating_add(Weight::from_ref_time(669_217 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(930_669 as u64) + // Standard Error: 396 + .saturating_add(Weight::from_ref_time(669_802 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 669 nanoseconds. - Weight::from_ref_time(811_434 as u64) - // Standard Error: 811 - .saturating_add(Weight::from_ref_time(932_974 as u64).saturating_mul(r as u64)) + // Minimum execution time: 701 nanoseconds. + Weight::from_ref_time(981_928 as u64) + // Standard Error: 826 + .saturating_add(Weight::from_ref_time(923_573 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 670 nanoseconds. - Weight::from_ref_time(510_094 as u64) - // Standard Error: 1_793 - .saturating_add(Weight::from_ref_time(1_255_401 as u64).saturating_mul(r as u64)) + // Minimum execution time: 697 nanoseconds. + Weight::from_ref_time(697_538 as u64) + // Standard Error: 1_419 + .saturating_add(Weight::from_ref_time(1_245_656 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 2_454 nanoseconds. - Weight::from_ref_time(2_721_478 as u64) - // Standard Error: 52 - .saturating_add(Weight::from_ref_time(3_520 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_581 nanoseconds. + Weight::from_ref_time(2_805_373 as u64) + // Standard Error: 55 + .saturating_add(Weight::from_ref_time(3_664 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(1_524_706 as u64) - // Standard Error: 4_023 - .saturating_add(Weight::from_ref_time(2_429_512 as u64).saturating_mul(r as u64)) + // Minimum execution time: 681 nanoseconds. + Weight::from_ref_time(1_346_495 as u64) + // Standard Error: 1_793 + .saturating_add(Weight::from_ref_time(2_362_769 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 711 nanoseconds. - Weight::from_ref_time(1_576_545 as u64) - // Standard Error: 2_825 - .saturating_add(Weight::from_ref_time(3_063_132 as u64).saturating_mul(r as u64)) + // Minimum execution time: 791 nanoseconds. + Weight::from_ref_time(2_082_854 as u64) + // Standard Error: 1_898 + .saturating_add(Weight::from_ref_time(3_004_674 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 4_577 nanoseconds. - Weight::from_ref_time(5_305_612 as u64) - // Standard Error: 218 - .saturating_add(Weight::from_ref_time(207_324 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_565 nanoseconds. + Weight::from_ref_time(5_403_098 as u64) + // Standard Error: 268 + .saturating_add(Weight::from_ref_time(208_007 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 1_450 nanoseconds. - Weight::from_ref_time(1_746_256 as u64) - // Standard Error: 337 - .saturating_add(Weight::from_ref_time(609_345 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_435 nanoseconds. + Weight::from_ref_time(1_817_646 as u64) + // Standard Error: 328 + .saturating_add(Weight::from_ref_time(609_595 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 1_457 nanoseconds. - Weight::from_ref_time(1_699_261 as u64) - // Standard Error: 212 - .saturating_add(Weight::from_ref_time(512_774 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_505 nanoseconds. + Weight::from_ref_time(1_787_731 as u64) + // Standard Error: 278 + .saturating_add(Weight::from_ref_time(512_746 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 1_449 nanoseconds. - Weight::from_ref_time(1_726_109 as u64) - // Standard Error: 540 - .saturating_add(Weight::from_ref_time(722_939 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_480 nanoseconds. + Weight::from_ref_time(1_799_405 as u64) + // Standard Error: 487 + .saturating_add(Weight::from_ref_time(722_985 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 707 nanoseconds. - Weight::from_ref_time(1_012_945 as u64) - // Standard Error: 456 - .saturating_add(Weight::from_ref_time(978_825 as u64).saturating_mul(r as u64)) + // Minimum execution time: 732 nanoseconds. + Weight::from_ref_time(1_134_852 as u64) + // Standard Error: 289 + .saturating_add(Weight::from_ref_time(844_232 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 718 nanoseconds. - Weight::from_ref_time(991_713 as u64) - // Standard Error: 376 - .saturating_add(Weight::from_ref_time(958_921 as u64).saturating_mul(r as u64)) + // Minimum execution time: 732 nanoseconds. + Weight::from_ref_time(1_101_513 as u64) + // Standard Error: 404 + .saturating_add(Weight::from_ref_time(853_552 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 737 nanoseconds. - Weight::from_ref_time(1_003_536 as u64) - // Standard Error: 357 - .saturating_add(Weight::from_ref_time(753_905 as u64).saturating_mul(r as u64)) + // Minimum execution time: 773 nanoseconds. + Weight::from_ref_time(1_028_022 as u64) + // Standard Error: 300 + .saturating_add(Weight::from_ref_time(735_549 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(720_128 as u64) - // Standard Error: 3_756 - .saturating_add(Weight::from_ref_time(188_693_871 as u64).saturating_mul(r as u64)) + // Minimum execution time: 685 nanoseconds. + Weight::from_ref_time(767_438 as u64) + // Standard Error: 5_152 + .saturating_add(Weight::from_ref_time(184_668_261 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(892_350 as u64) - // Standard Error: 221 - .saturating_add(Weight::from_ref_time(672_006 as u64).saturating_mul(r as u64)) + // Minimum execution time: 679 nanoseconds. + Weight::from_ref_time(988_596 as u64) + // Standard Error: 356 + .saturating_add(Weight::from_ref_time(671_490 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 652 nanoseconds. - Weight::from_ref_time(921_248 as u64) - // Standard Error: 298 - .saturating_add(Weight::from_ref_time(671_631 as u64).saturating_mul(r as u64)) + // Minimum execution time: 644 nanoseconds. + Weight::from_ref_time(967_209 as u64) + // Standard Error: 266 + .saturating_add(Weight::from_ref_time(671_486 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 645 nanoseconds. - Weight::from_ref_time(890_444 as u64) - // Standard Error: 247 - .saturating_add(Weight::from_ref_time(672_057 as u64).saturating_mul(r as u64)) + // Minimum execution time: 675 nanoseconds. + Weight::from_ref_time(957_638 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(671_491 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 684 nanoseconds. - Weight::from_ref_time(910_228 as u64) - // Standard Error: 171 - .saturating_add(Weight::from_ref_time(684_713 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(955_424 as u64) + // Standard Error: 203 + .saturating_add(Weight::from_ref_time(679_485 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 668 nanoseconds. - Weight::from_ref_time(874_456 as u64) - // Standard Error: 171 - .saturating_add(Weight::from_ref_time(671_242 as u64).saturating_mul(r as u64)) + // Minimum execution time: 697 nanoseconds. + Weight::from_ref_time(984_180 as u64) + // Standard Error: 229 + .saturating_add(Weight::from_ref_time(669_999 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 632 nanoseconds. - Weight::from_ref_time(900_807 as u64) - // Standard Error: 235 - .saturating_add(Weight::from_ref_time(670_298 as u64).saturating_mul(r as u64)) + // Minimum execution time: 684 nanoseconds. + Weight::from_ref_time(953_264 as u64) + // Standard Error: 236 + .saturating_add(Weight::from_ref_time(670_453 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 647 nanoseconds. - Weight::from_ref_time(910_984 as u64) - // Standard Error: 327 - .saturating_add(Weight::from_ref_time(671_129 as u64).saturating_mul(r as u64)) + // Minimum execution time: 688 nanoseconds. + Weight::from_ref_time(929_692 as u64) + // Standard Error: 329 + .saturating_add(Weight::from_ref_time(671_908 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 658 nanoseconds. - Weight::from_ref_time(895_986 as u64) - // Standard Error: 565 - .saturating_add(Weight::from_ref_time(913_649 as u64).saturating_mul(r as u64)) + // Minimum execution time: 639 nanoseconds. + Weight::from_ref_time(969_783 as u64) + // Standard Error: 264 + .saturating_add(Weight::from_ref_time(911_639 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 671 nanoseconds. - Weight::from_ref_time(892_539 as u64) - // Standard Error: 202 - .saturating_add(Weight::from_ref_time(913_503 as u64).saturating_mul(r as u64)) + // Minimum execution time: 691 nanoseconds. + Weight::from_ref_time(971_680 as u64) + // Standard Error: 321 + .saturating_add(Weight::from_ref_time(912_755 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 655 nanoseconds. - Weight::from_ref_time(960_186 as u64) - // Standard Error: 472 - .saturating_add(Weight::from_ref_time(922_417 as u64).saturating_mul(r as u64)) + // Minimum execution time: 669 nanoseconds. + Weight::from_ref_time(971_262 as u64) + // Standard Error: 225 + .saturating_add(Weight::from_ref_time(922_734 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 635 nanoseconds. - Weight::from_ref_time(870_482 as u64) - // Standard Error: 274 - .saturating_add(Weight::from_ref_time(914_130 as u64).saturating_mul(r as u64)) + // Minimum execution time: 654 nanoseconds. + Weight::from_ref_time(1_098_940 as u64) + // Standard Error: 944 + .saturating_add(Weight::from_ref_time(908_472 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 621 nanoseconds. - Weight::from_ref_time(891_451 as u64) - // Standard Error: 247 - .saturating_add(Weight::from_ref_time(909_133 as u64).saturating_mul(r as u64)) + // Minimum execution time: 729 nanoseconds. + Weight::from_ref_time(964_462 as u64) + // Standard Error: 256 + .saturating_add(Weight::from_ref_time(908_072 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 662 nanoseconds. - Weight::from_ref_time(904_400 as u64) - // Standard Error: 194 - .saturating_add(Weight::from_ref_time(917_254 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(948_256 as u64) + // Standard Error: 565 + .saturating_add(Weight::from_ref_time(920_128 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 673 nanoseconds. - Weight::from_ref_time(913_787 as u64) - // Standard Error: 185 - .saturating_add(Weight::from_ref_time(911_025 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(968_099 as u64) + // Standard Error: 368 + .saturating_add(Weight::from_ref_time(910_690 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(892_985 as u64) - // Standard Error: 175 - .saturating_add(Weight::from_ref_time(919_451 as u64).saturating_mul(r as u64)) + // Minimum execution time: 662 nanoseconds. + Weight::from_ref_time(972_425 as u64) + // Standard Error: 697 + .saturating_add(Weight::from_ref_time(922_352 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 666 nanoseconds. - Weight::from_ref_time(907_510 as u64) - // Standard Error: 204 - .saturating_add(Weight::from_ref_time(911_125 as u64).saturating_mul(r as u64)) + // Minimum execution time: 648 nanoseconds. + Weight::from_ref_time(949_113 as u64) + // Standard Error: 297 + .saturating_add(Weight::from_ref_time(912_150 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(896_012 as u64) - // Standard Error: 262 - .saturating_add(Weight::from_ref_time(911_762 as u64).saturating_mul(r as u64)) + // Minimum execution time: 673 nanoseconds. + Weight::from_ref_time(987_094 as u64) + // Standard Error: 301 + .saturating_add(Weight::from_ref_time(911_257 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 653 nanoseconds. - Weight::from_ref_time(921_793 as u64) - // Standard Error: 220 - .saturating_add(Weight::from_ref_time(900_803 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(981_475 as u64) + // Standard Error: 374 + .saturating_add(Weight::from_ref_time(901_865 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 676 nanoseconds. - Weight::from_ref_time(908_870 as u64) - // Standard Error: 277 - .saturating_add(Weight::from_ref_time(897_408 as u64).saturating_mul(r as u64)) + // Minimum execution time: 668 nanoseconds. + Weight::from_ref_time(965_213 as u64) + // Standard Error: 303 + .saturating_add(Weight::from_ref_time(896_888 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 671 nanoseconds. - Weight::from_ref_time(806_379 as u64) - // Standard Error: 638 - .saturating_add(Weight::from_ref_time(911_294 as u64).saturating_mul(r as u64)) + // Minimum execution time: 652 nanoseconds. + Weight::from_ref_time(980_542 as u64) + // Standard Error: 299 + .saturating_add(Weight::from_ref_time(905_822 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 639 nanoseconds. - Weight::from_ref_time(679_032 as u64) - // Standard Error: 6_536 - .saturating_add(Weight::from_ref_time(1_512_247 as u64).saturating_mul(r as u64)) + // Minimum execution time: 684 nanoseconds. + Weight::from_ref_time(925_256 as u64) + // Standard Error: 433 + .saturating_add(Weight::from_ref_time(1_499_876 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 653 nanoseconds. - Weight::from_ref_time(864_336 as u64) - // Standard Error: 251 - .saturating_add(Weight::from_ref_time(1_361_436 as u64).saturating_mul(r as u64)) + // Minimum execution time: 682 nanoseconds. + Weight::from_ref_time(967_909 as u64) + // Standard Error: 378 + .saturating_add(Weight::from_ref_time(1_363_274 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(969_193 as u64) - // Standard Error: 333 - .saturating_add(Weight::from_ref_time(1_521_975 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(983_259 as u64) + // Standard Error: 430 + .saturating_add(Weight::from_ref_time(1_526_000 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(869_301 as u64) - // Standard Error: 177 - .saturating_add(Weight::from_ref_time(1_361_528 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(933_173 as u64) + // Standard Error: 485 + .saturating_add(Weight::from_ref_time(1_364_737 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 626 nanoseconds. - Weight::from_ref_time(883_738 as u64) - // Standard Error: 288 - .saturating_add(Weight::from_ref_time(901_730 as u64).saturating_mul(r as u64)) + // Minimum execution time: 668 nanoseconds. + Weight::from_ref_time(874_117 as u64) + // Standard Error: 1_179 + .saturating_add(Weight::from_ref_time(908_945 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 637 nanoseconds. - Weight::from_ref_time(892_052 as u64) - // Standard Error: 297 - .saturating_add(Weight::from_ref_time(901_479 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(956_367 as u64) + // Standard Error: 470 + .saturating_add(Weight::from_ref_time(903_366 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 617 nanoseconds. - Weight::from_ref_time(882_714 as u64) - // Standard Error: 207 - .saturating_add(Weight::from_ref_time(901_984 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(957_477 as u64) + // Standard Error: 348 + .saturating_add(Weight::from_ref_time(902_774 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(885_605 as u64) - // Standard Error: 329 - .saturating_add(Weight::from_ref_time(911_644 as u64).saturating_mul(r as u64)) + // Minimum execution time: 666 nanoseconds. + Weight::from_ref_time(1_039_773 as u64) + // Standard Error: 409 + .saturating_add(Weight::from_ref_time(908_871 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 655 nanoseconds. - Weight::from_ref_time(916_923 as u64) - // Standard Error: 219 - .saturating_add(Weight::from_ref_time(910_766 as u64).saturating_mul(r as u64)) + // Minimum execution time: 659 nanoseconds. + Weight::from_ref_time(950_752 as u64) + // Standard Error: 398 + .saturating_add(Weight::from_ref_time(910_881 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 688 nanoseconds. - Weight::from_ref_time(890_697 as u64) - // Standard Error: 224 - .saturating_add(Weight::from_ref_time(910_605 as u64).saturating_mul(r as u64)) + // Minimum execution time: 677 nanoseconds. + Weight::from_ref_time(983_624 as u64) + // Standard Error: 286 + .saturating_add(Weight::from_ref_time(914_185 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 679 nanoseconds. - Weight::from_ref_time(964_104 as u64) - // Standard Error: 658 - .saturating_add(Weight::from_ref_time(908_547 as u64).saturating_mul(r as u64)) + // Minimum execution time: 652 nanoseconds. + Weight::from_ref_time(991_102 as u64) + // Standard Error: 316 + .saturating_add(Weight::from_ref_time(910_114 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 629 nanoseconds. - Weight::from_ref_time(879_488 as u64) - // Standard Error: 195 - .saturating_add(Weight::from_ref_time(910_911 as u64).saturating_mul(r as u64)) + // Minimum execution time: 664 nanoseconds. + Weight::from_ref_time(1_017_602 as u64) + // Standard Error: 965 + .saturating_add(Weight::from_ref_time(909_533 as u64).saturating_mul(r as u64)) } } From 6641366cf0f35df62a7e21503eb6eade9ebf6cb0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 13 Nov 2022 18:45:44 +0100 Subject: [PATCH 06/27] Apply suggestions from code review Co-authored-by: Robin Freyler --- frame/contracts/proc-macro/src/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index be174d0299664..b8322e4f53cd1 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -169,7 +169,7 @@ impl HostFnReturn { fn to_wasm_sig(&self) -> TokenStream2 { let ok = match self { Self::Unit => quote! { () }, - Self::U32 | Self::ReturnCode => quote! { u32 }, + Self::U32 | Self::ReturnCode => quote! { ::core::primitive::u32 }, }; quote! { Result<#ok, wasmi::core::Trap> @@ -400,7 +400,7 @@ fn expand_impls(def: &mut EnvDef) -> TokenStream2 { impl crate::wasm::Environment<()> for Env { - fn define(store: &mut wasmi::Store<()>, linker: &mut wasmi::Linker<()>) -> Result<(), wasmi::errors::LinkerError> { + fn define(store: &mut ::wasmi::Store<()>, linker: &mut ::wasmi::Linker<()>) -> Result<(), ::wasmi::errors::LinkerError> { #dummy_impls Ok(()) } @@ -443,7 +443,7 @@ fn expand_functions( } } } else { quote! { || -> #wasm_output { - unreachable!() + ::core::unreachable!() } } }; let map_err = if expand_blocks { From 59aaea8336ad0398769e4664f4a30d03f017d467 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 13 Nov 2022 18:52:54 +0100 Subject: [PATCH 07/27] Replace wasmi by ::wasmi --- frame/contracts/proc-macro/src/lib.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index b8322e4f53cd1..71576e8ab0dbc 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -172,7 +172,7 @@ impl HostFnReturn { Self::U32 | Self::ReturnCode => quote! { ::core::primitive::u32 }, }; quote! { - Result<#ok, wasmi::core::Trap> + Result<#ok, ::wasmi::core::Trap> } } } @@ -392,7 +392,7 @@ fn expand_impls(def: &mut EnvDef) -> TokenStream2 { ::AccountId: sp_core::crypto::UncheckedFrom<::Hash> + AsRef<[u8]>, { - fn define(store: &mut wasmi::Store>, linker: &mut wasmi::Linker>) -> Result<(), wasmi::errors::LinkerError> { + fn define(store: &mut ::wasmi::Store>, linker: &mut ::wasmi::Linker>) -> Result<(), ::wasmi::errors::LinkerError> { #impls Ok(()) } @@ -449,7 +449,7 @@ fn expand_functions( let map_err = if expand_blocks { quote! { |reason| { - wasmi::core::Trap::host(reason) + ::wasmi::core::Trap::host(reason) } } } else { @@ -467,7 +467,7 @@ fn expand_functions( quote! { #unstable_feat #allow_unused - linker.define(#module, #name, wasmi::Func::wrap(&mut*store, |mut __caller__: wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output { + linker.define(#module, #name, ::wasmi::Func::wrap(&mut*store, |mut __caller__: ::wasmi::Caller<#host_state>, #( #params, )*| -> #wasm_output { let mut func = #inner; func() .map_err(#map_err) From ac6c9570328c6c051031b483fff826584fa30070 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 13 Nov 2022 18:54:11 +0100 Subject: [PATCH 08/27] Bump wasmi to 0.20 --- Cargo.lock | 13 ++++++------- frame/contracts/Cargo.toml | 2 +- frame/contracts/src/wasm/mod.rs | 2 +- 3 files changed, 8 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 375b83f20c089..5a1e51e1a8f26 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5311,7 +5311,7 @@ dependencies = [ "sp-runtime", "sp-std", "wasm-instrument", - "wasmi 0.19.0", + "wasmi 0.20.0", "wasmparser-nostd", "wat", ] @@ -11612,13 +11612,13 @@ dependencies = [ [[package]] name = "wasmi" -version = "0.19.0" +version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7428e8361e19d3affa9221ad674014b4a29381b07c755aab9b1cd4f74610221a" +checksum = "01bf50edb2ea9d922aa75a7bf3c15e26a6c9e2d18c56e862b49737a582901729" dependencies = [ "spin 0.9.4", "wasmi_arena", - "wasmi_core 0.4.0", + "wasmi_core 0.5.0", "wasmparser-nostd", ] @@ -11652,13 +11652,12 @@ dependencies = [ [[package]] name = "wasmi_core" -version = "0.4.0" +version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c9559a70c22f27793520b9e098baea45915088fb5093dd7041fcfe238b95d4e" +checksum = "c5bf998ab792be85e20e771fe14182b4295571ad1d4f89d3da521c1bef5f597a" dependencies = [ "downcast-rs", "libm", - "memory_units", "num-traits", ] diff --git a/frame/contracts/Cargo.toml b/frame/contracts/Cargo.toml index 76cb605a13af2..e9c53dba0c545 100644 --- a/frame/contracts/Cargo.toml +++ b/frame/contracts/Cargo.toml @@ -25,7 +25,7 @@ serde = { version = "1", optional = true, features = ["derive"] } smallvec = { version = "1", default-features = false, features = [ "const_generics", ] } -wasmi = { version = "0.19", default-features = false } +wasmi = { version = "0.20", default-features = false } wasmparser = { package = "wasmparser-nostd", version = "0.91", default-features = false } impl-trait-for-tuples = "0.2" diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 9457694b451fb..49a18d3e56a4a 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -214,7 +214,7 @@ where let mut store = Store::new(&engine, host_state); let mut linker = Linker::new(); E::define(&mut store, &mut linker)?; - let memory = Memory::new(&mut store, MemoryType::new(memory.0, Some(memory.1))).expect( + let memory = Memory::new(&mut store, MemoryType::new(memory.0, Some(memory.1))?).expect( "Memory bounds are defined as `u32`. Hence the cannot be larger than u32::MAX; qed", ); linker From 8339073653acd902429e6925ddc67bda586a8ce7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 13 Nov 2022 18:56:39 +0100 Subject: [PATCH 09/27] Add explanation for `unreachable` --- frame/contracts/proc-macro/src/lib.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index 71576e8ab0dbc..f597cdbddf5c9 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -443,6 +443,9 @@ fn expand_functions( } } } 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!() } } }; From 4a3232140416768031db3c8151e812f538da0871 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Sun, 13 Nov 2022 18:59:38 +0100 Subject: [PATCH 10/27] Change proof --- frame/contracts/src/wasm/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 49a18d3e56a4a..7da4e49cacd52 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -215,7 +215,7 @@ where let mut linker = Linker::new(); E::define(&mut store, &mut linker)?; let memory = Memory::new(&mut store, MemoryType::new(memory.0, Some(memory.1))?).expect( - "Memory bounds are defined as `u32`. Hence the cannot be larger than u32::MAX; qed", + "The limits defined in our `Schedule` limit the amount of memory well below u32::MAX; qed", ); linker .define("env", "memory", memory) From f161f9d34332445c958c0b67baacdfcdbdab8ac8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Tue, 15 Nov 2022 14:17:39 +0100 Subject: [PATCH 11/27] Fixup master merge --- frame/contracts/src/wasm/runtime.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 79638329668f4..2615ee83b016b 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -2598,7 +2598,7 @@ pub mod env { /// /// Returns 0 when there is no reentrancy. #[unstable] - fn reentrant_count(ctx: Runtime) -> Result { + fn reentrant_count(ctx: _, memory: _) -> Result { ctx.charge_gas(RuntimeCosts::ReentrantCount)?; Ok(ctx.ext.reentrant_count()) } @@ -2614,10 +2614,10 @@ pub mod env { /// /// Returns 0 when the contract does not exist on the call stack. #[unstable] - fn account_reentrance_count(ctx: Runtime, account_ptr: u32) -> Result { + fn account_reentrance_count(ctx: _, memory: _, account_ptr: u32) -> Result { ctx.charge_gas(RuntimeCosts::AccountEntranceCount)?; let account_id: <::T as frame_system::Config>::AccountId = - ctx.read_sandbox_memory_as(account_ptr)?; + ctx.read_sandbox_memory_as(memory, account_ptr)?; Ok(ctx.ext.account_reentrance_count(&account_id)) } } From 938901b58235a41de006c4b72fbc27e9e6c92c68 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Tue, 15 Nov 2022 16:49:42 +0000 Subject: [PATCH 12/27] ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts --- frame/contracts/src/weights.rs | 1875 ++++++++++++++++---------------- 1 file changed, 944 insertions(+), 931 deletions(-) diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index 4652413df1158..bee0e6be683e2 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -18,24 +18,25 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-11-07, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! HOSTNAME: `bm2`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` +//! DATE: 2022-11-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 // Executed Command: -// ./target/production/substrate +// /home/benchbot/cargo_target_dir/production/substrate // benchmark // pallet -// --chain=dev // --steps=50 // --repeat=20 -// --pallet=pallet_contracts // --extrinsic=* // --execution=wasm // --wasm-execution=compiled // --heap-pages=4096 -// --output=./frame/contracts/src/weights.rs +// --json-file=/var/lib/gitlab-runner/builds/zyw4fam_/0/parity/mirrors/substrate/.git/.artifacts/bench.json +// --pallet=pallet_contracts +// --chain=dev // --header=./HEADER-APACHE2 +// --output=./frame/contracts/src/weights.rs // --template=./.maintain/frame-weight-template.hbs #![cfg_attr(rustfmt, rustfmt_skip)] @@ -109,8 +110,8 @@ pub trait WeightInfo { 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 seal_reentrant_count(r: u32, ) -> Weight; - fn seal_account_reentrance_count(r: u32, ) -> Weight; + fn reentrant_count(r: u32, ) -> Weight; + fn account_reentrance_count(r: u32, ) -> Weight; fn instr_i64const(r: u32, ) -> Weight; fn instr_i64load(r: u32, ) -> Weight; fn instr_i64store(r: u32, ) -> Weight; @@ -169,17 +170,17 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 3_064 nanoseconds. - Weight::from_ref_time(3_236_000 as u64) + // Minimum execution time: 3_092 nanoseconds. + Weight::from_ref_time(3_273_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 15_492 nanoseconds. - Weight::from_ref_time(14_309_233 as u64) - // Standard Error: 649 - .saturating_add(Weight::from_ref_time(930_078 as u64).saturating_mul(k as u64)) + // Minimum execution time: 15_553 nanoseconds. + Weight::from_ref_time(17_898_219 as u64) + // Standard Error: 612 + .saturating_add(Weight::from_ref_time(959_535 as u64).saturating_mul(k as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -187,10 +188,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 3_240 nanoseconds. - Weight::from_ref_time(15_076_559 as u64) - // Standard Error: 3_337 - .saturating_add(Weight::from_ref_time(1_244_348 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_051 nanoseconds. + Weight::from_ref_time(16_045_885 as u64) + // Standard Error: 3_894 + .saturating_add(Weight::from_ref_time(1_251_095 as u64).saturating_mul(q as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -198,10 +199,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 22_524 nanoseconds. - Weight::from_ref_time(19_939_078 as u64) - // Standard Error: 43 - .saturating_add(Weight::from_ref_time(43_802 as u64).saturating_mul(c as u64)) + // Minimum execution time: 29_767 nanoseconds. + Weight::from_ref_time(24_442_384 as u64) + // Standard Error: 41 + .saturating_add(Weight::from_ref_time(47_060 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -212,10 +213,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 261_039 nanoseconds. - Weight::from_ref_time(228_709_853 as u64) - // Standard Error: 105 - .saturating_add(Weight::from_ref_time(47_449 as u64).saturating_mul(c as u64)) + // Minimum execution time: 307_279 nanoseconds. + Weight::from_ref_time(317_807_474 as u64) + // Standard Error: 17 + .saturating_add(Weight::from_ref_time(30_874 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -230,12 +231,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_054_867 nanoseconds. - Weight::from_ref_time(259_090_306 as u64) - // Standard Error: 72 - .saturating_add(Weight::from_ref_time(107_519 as u64).saturating_mul(c as u64)) - // Standard Error: 4 - .saturating_add(Weight::from_ref_time(1_736 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_173_376 nanoseconds. + Weight::from_ref_time(333_991_198 as u64) + // Standard Error: 47 + .saturating_add(Weight::from_ref_time(90_283 as u64).saturating_mul(c as u64)) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_782 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } @@ -248,10 +249,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 213_409 nanoseconds. - Weight::from_ref_time(205_300_495 as u64) + // Minimum execution time: 187_549 nanoseconds. + Weight::from_ref_time(176_268_968 as u64) // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_479 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_525 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } @@ -261,8 +262,8 @@ impl WeightInfo for SubstrateWeight { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 183_317 nanoseconds. - Weight::from_ref_time(184_465_000 as u64) + // Minimum execution time: 156_476 nanoseconds. + Weight::from_ref_time(157_462_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -272,10 +273,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 56_187 nanoseconds. - Weight::from_ref_time(60_636_621 as u64) - // Standard Error: 46 - .saturating_add(Weight::from_ref_time(45_734 as u64).saturating_mul(c as u64)) + // Minimum execution time: 295_320 nanoseconds. + Weight::from_ref_time(305_011_007 as u64) + // Standard Error: 53 + .saturating_add(Weight::from_ref_time(77_528 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -284,8 +285,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 38_433 nanoseconds. - Weight::from_ref_time(38_917_000 as u64) + // Minimum execution time: 39_868 nanoseconds. + Weight::from_ref_time(40_885_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -293,8 +294,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 41_507 nanoseconds. - Weight::from_ref_time(41_938_000 as u64) + // Minimum execution time: 42_082 nanoseconds. + Weight::from_ref_time(42_487_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } @@ -305,10 +306,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 249_628 nanoseconds. - Weight::from_ref_time(251_997_923 as u64) - // Standard Error: 26_157 - .saturating_add(Weight::from_ref_time(35_002_004 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_276 nanoseconds. + Weight::from_ref_time(300_528_395 as u64) + // Standard Error: 22_438 + .saturating_add(Weight::from_ref_time(16_661_252 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -319,10 +320,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 249_390 nanoseconds. - Weight::from_ref_time(193_793_052 as u64) - // Standard Error: 430_292 - .saturating_add(Weight::from_ref_time(211_029_686 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_022 nanoseconds. + Weight::from_ref_time(231_263_577 as u64) + // Standard Error: 430_945 + .saturating_add(Weight::from_ref_time(199_389_344 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -334,10 +335,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 252_469 nanoseconds. - Weight::from_ref_time(201_438_856 as u64) - // Standard Error: 420_040 - .saturating_add(Weight::from_ref_time(267_340_744 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_796 nanoseconds. + Weight::from_ref_time(243_158_249 as u64) + // Standard Error: 396_560 + .saturating_add(Weight::from_ref_time(242_784_462 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -349,10 +350,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 251_154 nanoseconds. - Weight::from_ref_time(254_831_062 as u64) - // Standard Error: 37_843 - .saturating_add(Weight::from_ref_time(38_579_567 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_206 nanoseconds. + Weight::from_ref_time(302_423_708 as u64) + // Standard Error: 18_660 + .saturating_add(Weight::from_ref_time(20_507_825 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -363,10 +364,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 247_875 nanoseconds. - Weight::from_ref_time(250_312_587 as u64) - // Standard Error: 17_901 - .saturating_add(Weight::from_ref_time(15_153_431 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_337 nanoseconds. + Weight::from_ref_time(298_462_585 as u64) + // Standard Error: 15_979 + .saturating_add(Weight::from_ref_time(11_165_786 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -377,10 +378,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 250_097 nanoseconds. - Weight::from_ref_time(252_157_442 as u64) - // Standard Error: 38_426 - .saturating_add(Weight::from_ref_time(35_084_205 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_982 nanoseconds. + Weight::from_ref_time(299_538_930 as u64) + // Standard Error: 18_777 + .saturating_add(Weight::from_ref_time(16_575_318 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -391,10 +392,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 250_034 nanoseconds. - Weight::from_ref_time(252_189_233 as u64) - // Standard Error: 33_081 - .saturating_add(Weight::from_ref_time(34_764_160 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_266 nanoseconds. + Weight::from_ref_time(301_023_294 as u64) + // Standard Error: 18_987 + .saturating_add(Weight::from_ref_time(16_152_668 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -405,10 +406,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 249_587 nanoseconds. - Weight::from_ref_time(258_565_111 as u64) - // Standard Error: 75_715 - .saturating_add(Weight::from_ref_time(109_687_486 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_847 nanoseconds. + Weight::from_ref_time(302_991_846 as u64) + // Standard Error: 36_830 + .saturating_add(Weight::from_ref_time(89_091_598 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -419,10 +420,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 249_735 nanoseconds. - Weight::from_ref_time(252_875_784 as u64) - // Standard Error: 42_024 - .saturating_add(Weight::from_ref_time(34_555_983 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_907 nanoseconds. + Weight::from_ref_time(300_322_285 as u64) + // Standard Error: 20_612 + .saturating_add(Weight::from_ref_time(16_199_834 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -433,10 +434,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 250_025 nanoseconds. - Weight::from_ref_time(255_212_046 as u64) - // Standard Error: 41_865 - .saturating_add(Weight::from_ref_time(34_332_291 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_042 nanoseconds. + Weight::from_ref_time(299_750_507 as u64) + // Standard Error: 19_981 + .saturating_add(Weight::from_ref_time(16_290_215 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -447,10 +448,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 247_641 nanoseconds. - Weight::from_ref_time(252_978_686 as u64) - // Standard Error: 25_820 - .saturating_add(Weight::from_ref_time(34_175_386 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_129 nanoseconds. + Weight::from_ref_time(301_389_224 as u64) + // Standard Error: 20_956 + .saturating_add(Weight::from_ref_time(15_947_448 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -461,10 +462,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 249_871 nanoseconds. - Weight::from_ref_time(253_237_931 as u64) - // Standard Error: 30_986 - .saturating_add(Weight::from_ref_time(34_305_155 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_128 nanoseconds. + Weight::from_ref_time(299_569_582 as u64) + // Standard Error: 18_853 + .saturating_add(Weight::from_ref_time(16_304_774 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -476,10 +477,10 @@ impl WeightInfo for SubstrateWeight { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 249_787 nanoseconds. - Weight::from_ref_time(258_457_094 as u64) - // Standard Error: 75_835 - .saturating_add(Weight::from_ref_time(107_115_666 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_229 nanoseconds. + Weight::from_ref_time(305_986_569 as u64) + // Standard Error: 33_339 + .saturating_add(Weight::from_ref_time(85_497_208 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -490,10 +491,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 171_667 nanoseconds. - Weight::from_ref_time(174_687_863 as u64) - // Standard Error: 34_576 - .saturating_add(Weight::from_ref_time(15_895_674 as u64).saturating_mul(r as u64)) + // Minimum execution time: 144_560 nanoseconds. + Weight::from_ref_time(147_780_996 as u64) + // Standard Error: 8_658 + .saturating_add(Weight::from_ref_time(8_185_717 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -504,10 +505,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 249_610 nanoseconds. - Weight::from_ref_time(251_476_758 as u64) - // Standard Error: 39_422 - .saturating_add(Weight::from_ref_time(32_870_429 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_869 nanoseconds. + Weight::from_ref_time(300_501_085 as u64) + // Standard Error: 17_955 + .saturating_add(Weight::from_ref_time(13_899_691 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -518,10 +519,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 285_154 nanoseconds. - Weight::from_ref_time(307_768_636 as u64) - // Standard Error: 2_701 - .saturating_add(Weight::from_ref_time(9_544_122 as u64).saturating_mul(n as u64)) + // Minimum execution time: 312_247 nanoseconds. + Weight::from_ref_time(327_623_543 as u64) + // Standard Error: 1_162 + .saturating_add(Weight::from_ref_time(9_752_573 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -532,10 +533,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 244_810 nanoseconds. - Weight::from_ref_time(247_576_385 as u64) - // Standard Error: 80_494 - .saturating_add(Weight::from_ref_time(2_052_714 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_105 nanoseconds. + Weight::from_ref_time(296_353_112 as u64) + // Standard Error: 558_302 + .saturating_add(Weight::from_ref_time(1_012_487 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -546,10 +547,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 248_049 nanoseconds. - Weight::from_ref_time(250_148_025 as u64) - // Standard Error: 339 - .saturating_add(Weight::from_ref_time(185_344 as u64).saturating_mul(n as u64)) + // Minimum execution time: 295_097 nanoseconds. + Weight::from_ref_time(298_173_380 as u64) + // Standard Error: 325 + .saturating_add(Weight::from_ref_time(191_050 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -562,10 +563,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 246_620 nanoseconds. - Weight::from_ref_time(250_752_277 as u64) - // Standard Error: 84_300 - .saturating_add(Weight::from_ref_time(54_264_722 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_339 nanoseconds. + Weight::from_ref_time(297_328_822 as u64) + // Standard Error: 536_109 + .saturating_add(Weight::from_ref_time(53_529_277 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -579,10 +580,10 @@ impl WeightInfo for SubstrateWeight { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 249_065 nanoseconds. - Weight::from_ref_time(252_419_902 as u64) - // Standard Error: 84_223 - .saturating_add(Weight::from_ref_time(134_454_079 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_833 nanoseconds. + Weight::from_ref_time(303_220_868 as u64) + // Standard Error: 46_963 + .saturating_add(Weight::from_ref_time(108_698_031 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -593,10 +594,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 246_588 nanoseconds. - Weight::from_ref_time(261_525_328 as u64) - // Standard Error: 97_732 - .saturating_add(Weight::from_ref_time(235_555_878 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_111 nanoseconds. + Weight::from_ref_time(304_357_752 as u64) + // Standard Error: 84_942 + .saturating_add(Weight::from_ref_time(218_943_695 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -608,12 +609,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_171_144 nanoseconds. - Weight::from_ref_time(490_333_337 as u64) - // Standard Error: 404_664 - .saturating_add(Weight::from_ref_time(173_683_265 as u64).saturating_mul(t as u64)) - // Standard Error: 111_140 - .saturating_add(Weight::from_ref_time(66_081_822 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_188_981 nanoseconds. + Weight::from_ref_time(494_557_508 as u64) + // Standard Error: 335_039 + .saturating_add(Weight::from_ref_time(176_656_427 as u64).saturating_mul(t as u64)) + // Standard Error: 92_018 + .saturating_add(Weight::from_ref_time(70_000_320 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -626,20 +627,20 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 178_822 nanoseconds. - Weight::from_ref_time(181_571_518 as u64) - // Standard Error: 19_207 - .saturating_add(Weight::from_ref_time(26_784_712 as u64).saturating_mul(r as u64)) + // Minimum execution time: 157_568 nanoseconds. + Weight::from_ref_time(161_449_917 as u64) + // Standard Error: 13_938 + .saturating_add(Weight::from_ref_time(12_897_245 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 249_737 nanoseconds. - Weight::from_ref_time(208_095_467 as u64) - // Standard Error: 417_236 - .saturating_add(Weight::from_ref_time(430_088_574 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_001 nanoseconds. + Weight::from_ref_time(248_958_000 as u64) + // Standard Error: 472_012 + .saturating_add(Weight::from_ref_time(418_368_781 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -648,10 +649,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 400_055 nanoseconds. - Weight::from_ref_time(551_666_883 as u64) - // Standard Error: 1_379_652 - .saturating_add(Weight::from_ref_time(94_069_118 as u64).saturating_mul(n as u64)) + // Minimum execution time: 433_239 nanoseconds. + Weight::from_ref_time(588_857_373 as u64) + // Standard Error: 1_426_031 + .saturating_add(Weight::from_ref_time(92_895_050 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(52 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(50 as u64)) @@ -660,10 +661,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 400_370 nanoseconds. - Weight::from_ref_time(521_380_000 as u64) - // Standard Error: 1_112_618 - .saturating_add(Weight::from_ref_time(68_664_898 as u64).saturating_mul(n as u64)) + // Minimum execution time: 432_591 nanoseconds. + Weight::from_ref_time(563_499_766 as u64) + // Standard Error: 1_212_322 + .saturating_add(Weight::from_ref_time(65_491_920 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(49 as u64)) @@ -672,10 +673,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 249_711 nanoseconds. - Weight::from_ref_time(212_629_798 as u64) - // Standard Error: 378_159 - .saturating_add(Weight::from_ref_time(415_326_230 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_678 nanoseconds. + Weight::from_ref_time(250_903_819 as u64) + // Standard Error: 483_469 + .saturating_add(Weight::from_ref_time(410_221_708 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -684,10 +685,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 365_702 nanoseconds. - Weight::from_ref_time(499_337_686 as u64) - // Standard Error: 1_232_330 - .saturating_add(Weight::from_ref_time(70_648_878 as u64).saturating_mul(n as u64)) + // Minimum execution time: 401_147 nanoseconds. + Weight::from_ref_time(547_029_800 as u64) + // Standard Error: 1_350_158 + .saturating_add(Weight::from_ref_time(66_946_722 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -696,10 +697,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 251_357 nanoseconds. - Weight::from_ref_time(220_533_580 as u64) - // Standard Error: 345_297 - .saturating_add(Weight::from_ref_time(349_413_968 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_061 nanoseconds. + Weight::from_ref_time(257_651_770 as u64) + // Standard Error: 444_344 + .saturating_add(Weight::from_ref_time(329_428_375 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -707,10 +708,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 354_162 nanoseconds. - Weight::from_ref_time(472_811_575 as u64) - // Standard Error: 1_109_282 - .saturating_add(Weight::from_ref_time(154_074_386 as u64).saturating_mul(n as u64)) + // Minimum execution time: 377_320 nanoseconds. + Weight::from_ref_time(506_517_859 as u64) + // Standard Error: 1_210_985 + .saturating_add(Weight::from_ref_time(154_977_621 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -718,10 +719,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 247_551 nanoseconds. - Weight::from_ref_time(219_176_526 as u64) - // Standard Error: 358_914 - .saturating_add(Weight::from_ref_time(326_009_513 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_753 nanoseconds. + Weight::from_ref_time(260_829_553 as u64) + // Standard Error: 432_834 + .saturating_add(Weight::from_ref_time(317_967_995 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -729,10 +730,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 339_149 nanoseconds. - Weight::from_ref_time(440_615_016 as u64) - // Standard Error: 954_837 - .saturating_add(Weight::from_ref_time(66_153_533 as u64).saturating_mul(n as u64)) + // Minimum execution time: 373_049 nanoseconds. + Weight::from_ref_time(484_443_595 as u64) + // Standard Error: 1_048_752 + .saturating_add(Weight::from_ref_time(64_192_391 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -740,10 +741,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 251_812 nanoseconds. - Weight::from_ref_time(209_954_069 as u64) - // Standard Error: 398_380 - .saturating_add(Weight::from_ref_time(438_573_954 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_893 nanoseconds. + Weight::from_ref_time(256_830_685 as u64) + // Standard Error: 436_220 + .saturating_add(Weight::from_ref_time(418_336_409 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -752,10 +753,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 374_594 nanoseconds. - Weight::from_ref_time(525_213_792 as u64) - // Standard Error: 1_378_489 - .saturating_add(Weight::from_ref_time(161_599_623 as u64).saturating_mul(n as u64)) + // Minimum execution time: 402_327 nanoseconds. + Weight::from_ref_time(562_732_190 as u64) + // Standard Error: 1_453_818 + .saturating_add(Weight::from_ref_time(159_662_683 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -768,10 +769,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 251_379 nanoseconds. - Weight::from_ref_time(204_214_298 as u64) - // Standard Error: 662_575 - .saturating_add(Weight::from_ref_time(1_366_716_853 as u64).saturating_mul(r as u64)) + // Minimum execution time: 298_014 nanoseconds. + Weight::from_ref_time(248_052_379 as u64) + // Standard Error: 595_597 + .saturating_add(Weight::from_ref_time(1_341_846_920 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -784,10 +785,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 252_896 nanoseconds. - Weight::from_ref_time(253_811_000 as u64) - // Standard Error: 6_576_179 - .saturating_add(Weight::from_ref_time(17_254_952_849 as u64).saturating_mul(r as u64)) + // Minimum execution time: 298_250 nanoseconds. + Weight::from_ref_time(299_254_000 as u64) + // Standard Error: 8_061_285 + .saturating_add(Weight::from_ref_time(21_176_072_564 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -800,10 +801,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 249_312 nanoseconds. - Weight::from_ref_time(253_806_000 as u64) - // Standard Error: 6_118_873 - .saturating_add(Weight::from_ref_time(17_081_370_212 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_286 nanoseconds. + Weight::from_ref_time(505_420_101 as u64) + // Standard Error: 12_020_807 + .saturating_add(Weight::from_ref_time(20_502_779_430 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -817,12 +818,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 12_001_522 nanoseconds. - Weight::from_ref_time(10_903_312_955 as u64) - // Standard Error: 4_301_096 - .saturating_add(Weight::from_ref_time(1_243_413_241 as u64).saturating_mul(t as u64)) - // Standard Error: 6_449 - .saturating_add(Weight::from_ref_time(9_713_655 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_465_740 nanoseconds. + Weight::from_ref_time(8_443_609_945 as u64) + // Standard Error: 6_130_641 + .saturating_add(Weight::from_ref_time(1_269_904_453 as u64).saturating_mul(t as u64)) + // Standard Error: 9_192 + .saturating_add(Weight::from_ref_time(9_821_368 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(167 as u64)) .saturating_add(T::DbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(163 as u64)) @@ -837,10 +838,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 254_969 nanoseconds. - Weight::from_ref_time(255_984_000 as u64) - // Standard Error: 18_545_048 - .saturating_add(Weight::from_ref_time(22_343_189_765 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_708 nanoseconds. + Weight::from_ref_time(294_333_000 as u64) + // Standard Error: 19_087_339 + .saturating_add(Weight::from_ref_time(25_796_470_079 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(5 as u64)) @@ -856,10 +857,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 14_077_497 nanoseconds. - Weight::from_ref_time(13_949_740_588 as u64) - // Standard Error: 66_631 - .saturating_add(Weight::from_ref_time(120_519_572 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_500_978 nanoseconds. + Weight::from_ref_time(11_033_266_932 as u64) + // Standard Error: 48_183_801 + .saturating_add(Weight::from_ref_time(36_156_854 as u64).saturating_mul(t as u64)) + // Standard Error: 77_067 + .saturating_add(Weight::from_ref_time(122_691_370 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(249 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(247 as u64)) @@ -872,10 +875,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 247_445 nanoseconds. - Weight::from_ref_time(251_229_791 as u64) - // Standard Error: 88_045 - .saturating_add(Weight::from_ref_time(57_577_008 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_534 nanoseconds. + Weight::from_ref_time(292_978_777 as u64) + // Standard Error: 612_499 + .saturating_add(Weight::from_ref_time(41_539_022 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -886,10 +889,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 308_069 nanoseconds. - Weight::from_ref_time(308_971_000 as u64) - // Standard Error: 46_181 - .saturating_add(Weight::from_ref_time(321_835_684 as u64).saturating_mul(n as u64)) + // Minimum execution time: 331_137 nanoseconds. + Weight::from_ref_time(332_503_000 as u64) + // Standard Error: 56_729 + .saturating_add(Weight::from_ref_time(325_461_347 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -900,10 +903,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 247_107 nanoseconds. - Weight::from_ref_time(250_125_030 as u64) - // Standard Error: 88_769 - .saturating_add(Weight::from_ref_time(70_727_669 as u64).saturating_mul(r as u64)) + // Minimum execution time: 288_957 nanoseconds. + Weight::from_ref_time(292_957_579 as u64) + // Standard Error: 636_977 + .saturating_add(Weight::from_ref_time(60_789_720 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -914,10 +917,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 319_515 nanoseconds. - Weight::from_ref_time(319_784_000 as u64) - // Standard Error: 58_896 - .saturating_add(Weight::from_ref_time(246_433_962 as u64).saturating_mul(n as u64)) + // Minimum execution time: 343_123 nanoseconds. + Weight::from_ref_time(343_741_000 as u64) + // Standard Error: 58_203 + .saturating_add(Weight::from_ref_time(247_808_004 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -928,10 +931,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 247_887 nanoseconds. - Weight::from_ref_time(250_452_702 as u64) - // Standard Error: 140_887 - .saturating_add(Weight::from_ref_time(49_538_397 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_493 nanoseconds. + Weight::from_ref_time(293_256_030 as u64) + // Standard Error: 608_271 + .saturating_add(Weight::from_ref_time(31_193_669 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -942,10 +945,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 297_534 nanoseconds. - Weight::from_ref_time(298_249_000 as u64) - // Standard Error: 49_680 - .saturating_add(Weight::from_ref_time(99_001_103 as u64).saturating_mul(n as u64)) + // Minimum execution time: 321_692 nanoseconds. + Weight::from_ref_time(322_518_000 as u64) + // Standard Error: 50_856 + .saturating_add(Weight::from_ref_time(99_851_120 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -956,10 +959,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 245_926 nanoseconds. - Weight::from_ref_time(248_471_834 as u64) - // Standard Error: 101_639 - .saturating_add(Weight::from_ref_time(47_889_865 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_829 nanoseconds. + Weight::from_ref_time(291_929_059 as u64) + // Standard Error: 609_982 + .saturating_add(Weight::from_ref_time(30_437_840 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -970,10 +973,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 294_835 nanoseconds. - Weight::from_ref_time(296_328_000 as u64) - // Standard Error: 46_612 - .saturating_add(Weight::from_ref_time(98_859_152 as u64).saturating_mul(n as u64)) + // Minimum execution time: 320_218 nanoseconds. + Weight::from_ref_time(320_820_000 as u64) + // Standard Error: 49_721 + .saturating_add(Weight::from_ref_time(99_723_926 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -984,10 +987,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 251_104 nanoseconds. - Weight::from_ref_time(253_114_893 as u64) - // Standard Error: 316_740 - .saturating_add(Weight::from_ref_time(2_964_072_706 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_068 nanoseconds. + Weight::from_ref_time(294_064_673 as u64) + // Standard Error: 818_242 + .saturating_add(Weight::from_ref_time(3_038_409_926 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -998,10 +1001,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 250_048 nanoseconds. - Weight::from_ref_time(251_774_991 as u64) - // Standard Error: 115_294 - .saturating_add(Weight::from_ref_time(2_094_245_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_271 nanoseconds. + Weight::from_ref_time(293_100_328 as u64) + // Standard Error: 658_900 + .saturating_add(Weight::from_ref_time(2_070_519_571 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1013,10 +1016,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 250_830 nanoseconds. - Weight::from_ref_time(251_477_000 as u64) - // Standard Error: 2_727_998 - .saturating_add(Weight::from_ref_time(1_390_149_283 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_181 nanoseconds. + Weight::from_ref_time(290_618_000 as u64) + // Standard Error: 2_652_670 + .saturating_add(Weight::from_ref_time(1_362_797_408 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -1026,382 +1029,386 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) + // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_reentrant_count(r: u32, ) -> Weight { - Weight::from_ref_time(304_709_000 as u64) - // Standard Error: 67_000 - .saturating_add(Weight::from_ref_time(15_411_000 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(4 as u64)) - .saturating_add(T::DbWeight::get().writes(1 as u64)) + fn reentrant_count(r: u32, ) -> Weight { + // Minimum execution time: 290_954 nanoseconds. + Weight::from_ref_time(295_190_436 as u64) + // Standard Error: 40_295 + .saturating_add(Weight::from_ref_time(11_022_974 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) + // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { - Weight::from_ref_time(328_378_000 as u64) - // Standard Error: 137_000 - .saturating_add(Weight::from_ref_time(37_448_000 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(4 as u64)) - .saturating_add(T::DbWeight::get().writes(1 as u64)) + fn account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 292_817 nanoseconds. + Weight::from_ref_time(331_195_835 as u64) + // Standard Error: 126_642 + .saturating_add(Weight::from_ref_time(25_590_472 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(3 as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 69_022 nanoseconds. - Weight::from_ref_time(69_707_657 as u64) - // Standard Error: 8_674 - .saturating_add(Weight::from_ref_time(887_555 as u64).saturating_mul(r as u64)) + // Minimum execution time: 605 nanoseconds. + Weight::from_ref_time(866_109 as u64) + // Standard Error: 275 + .saturating_add(Weight::from_ref_time(346_136 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 69_491 nanoseconds. - Weight::from_ref_time(70_354_670 as u64) - // Standard Error: 1_518 - .saturating_add(Weight::from_ref_time(2_758_912 as u64).saturating_mul(r as u64)) + // Minimum execution time: 718 nanoseconds. + Weight::from_ref_time(1_402_372 as u64) + // Standard Error: 2_693 + .saturating_add(Weight::from_ref_time(985_910 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 69_156 nanoseconds. - Weight::from_ref_time(69_917_601 as u64) - // Standard Error: 1_970 - .saturating_add(Weight::from_ref_time(2_753_174 as u64).saturating_mul(r as u64)) + // Minimum execution time: 706 nanoseconds. + Weight::from_ref_time(1_120_197 as u64) + // Standard Error: 394 + .saturating_add(Weight::from_ref_time(889_593 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 68_944 nanoseconds. - Weight::from_ref_time(69_727_961 as u64) - // Standard Error: 376 - .saturating_add(Weight::from_ref_time(2_356_996 as u64).saturating_mul(r as u64)) + // Minimum execution time: 644 nanoseconds. + Weight::from_ref_time(1_057_422 as u64) + // Standard Error: 857 + .saturating_add(Weight::from_ref_time(955_777 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 68_971 nanoseconds. - Weight::from_ref_time(69_755_949 as u64) - // Standard Error: 543 - .saturating_add(Weight::from_ref_time(2_489_510 as u64).saturating_mul(r as u64)) + // Minimum execution time: 637 nanoseconds. + Weight::from_ref_time(629_141 as u64) + // Standard Error: 544 + .saturating_add(Weight::from_ref_time(1_293_126 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 69_061 nanoseconds. - Weight::from_ref_time(69_625_000 as u64) - // Standard Error: 486 - .saturating_add(Weight::from_ref_time(1_431_684 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(1_113_576 as u64) + // Standard Error: 880 + .saturating_add(Weight::from_ref_time(527_673 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 69_058 nanoseconds. - Weight::from_ref_time(69_521_790 as u64) - // Standard Error: 892 - .saturating_add(Weight::from_ref_time(1_964_054 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(170_717 as u64) + // Standard Error: 1_959 + .saturating_add(Weight::from_ref_time(867_748 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 69_020 nanoseconds. - Weight::from_ref_time(69_344_255 as u64) - // Standard Error: 1_408 - .saturating_add(Weight::from_ref_time(2_169_179 as u64).saturating_mul(r as u64)) + // Minimum execution time: 648 nanoseconds. + Weight::from_ref_time(539_108 as u64) + // Standard Error: 1_490 + .saturating_add(Weight::from_ref_time(1_077_401 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 72_366 nanoseconds. - Weight::from_ref_time(72_869_594 as u64) - // Standard Error: 73 - .saturating_add(Weight::from_ref_time(3_867 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_179 nanoseconds. + Weight::from_ref_time(2_597_080 as u64) + // Standard Error: 74 + .saturating_add(Weight::from_ref_time(4_865 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 69_164 nanoseconds. - Weight::from_ref_time(70_269_099 as u64) - // Standard Error: 8_824 - .saturating_add(Weight::from_ref_time(6_594_634 as u64).saturating_mul(r as u64)) + // Minimum execution time: 633 nanoseconds. + Weight::from_ref_time(1_498_082 as u64) + // Standard Error: 1_780 + .saturating_add(Weight::from_ref_time(2_198_342 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 83_348 nanoseconds. - Weight::from_ref_time(84_968_895 as u64) - // Standard Error: 6_305 - .saturating_add(Weight::from_ref_time(8_395_193 as u64).saturating_mul(r as u64)) + // Minimum execution time: 806 nanoseconds. + Weight::from_ref_time(1_904_912 as u64) + // Standard Error: 1_182 + .saturating_add(Weight::from_ref_time(2_801_959 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 92_358 nanoseconds. - Weight::from_ref_time(93_605_536 as u64) - // Standard Error: 2_019 - .saturating_add(Weight::from_ref_time(536_495 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_219 nanoseconds. + Weight::from_ref_time(5_152_036 as u64) + // Standard Error: 290 + .saturating_add(Weight::from_ref_time(179_507 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 69_191 nanoseconds. - Weight::from_ref_time(70_407_702 as u64) - // Standard Error: 2_812 - .saturating_add(Weight::from_ref_time(901_706 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_438 nanoseconds. + Weight::from_ref_time(1_730_599 as u64) + // Standard Error: 208 + .saturating_add(Weight::from_ref_time(364_842 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 69_230 nanoseconds. - Weight::from_ref_time(70_255_278 as u64) - // Standard Error: 1_284 - .saturating_add(Weight::from_ref_time(951_754 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_430 nanoseconds. + Weight::from_ref_time(1_671_358 as u64) + // Standard Error: 276 + .saturating_add(Weight::from_ref_time(383_715 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 69_278 nanoseconds. - Weight::from_ref_time(70_089_139 as u64) - // Standard Error: 757 - .saturating_add(Weight::from_ref_time(1_369_185 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_394 nanoseconds. + Weight::from_ref_time(1_708_668 as u64) + // Standard Error: 199 + .saturating_add(Weight::from_ref_time(526_648 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 72_047 nanoseconds. - Weight::from_ref_time(72_783_972 as u64) - // Standard Error: 837 - .saturating_add(Weight::from_ref_time(1_471_680 as u64).saturating_mul(r as u64)) + // Minimum execution time: 713 nanoseconds. + Weight::from_ref_time(1_095_871 as u64) + // Standard Error: 343 + .saturating_add(Weight::from_ref_time(811_365 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 71_960 nanoseconds. - Weight::from_ref_time(72_745_981 as u64) - // Standard Error: 1_086 - .saturating_add(Weight::from_ref_time(1_537_741 as u64).saturating_mul(r as u64)) + // Minimum execution time: 727 nanoseconds. + Weight::from_ref_time(1_056_556 as u64) + // Standard Error: 355 + .saturating_add(Weight::from_ref_time(830_505 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 69_221 nanoseconds. - Weight::from_ref_time(70_010_862 as u64) - // Standard Error: 1_845 - .saturating_add(Weight::from_ref_time(933_738 as u64).saturating_mul(r as u64)) + // Minimum execution time: 753 nanoseconds. + Weight::from_ref_time(1_004_624 as u64) + // Standard Error: 259 + .saturating_add(Weight::from_ref_time(693_886 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 69_081 nanoseconds. - Weight::from_ref_time(71_015_495 as u64) - // Standard Error: 27_078 - .saturating_add(Weight::from_ref_time(183_899_704 as u64).saturating_mul(r as u64)) + // Minimum execution time: 649 nanoseconds. + Weight::from_ref_time(742_979 as u64) + // Standard Error: 5_852 + .saturating_add(Weight::from_ref_time(184_932_720 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 70_589 nanoseconds. - Weight::from_ref_time(70_175_537 as u64) - // Standard Error: 1_355 - .saturating_add(Weight::from_ref_time(1_323_745 as u64).saturating_mul(r as u64)) + // Minimum execution time: 615 nanoseconds. + Weight::from_ref_time(919_735 as u64) + // Standard Error: 443 + .saturating_add(Weight::from_ref_time(509_234 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 69_083 nanoseconds. - Weight::from_ref_time(69_832_339 as u64) - // Standard Error: 818 - .saturating_add(Weight::from_ref_time(1_334_198 as u64).saturating_mul(r as u64)) + // Minimum execution time: 623 nanoseconds. + Weight::from_ref_time(883_408 as u64) + // Standard Error: 437 + .saturating_add(Weight::from_ref_time(517_270 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 69_084 nanoseconds. - Weight::from_ref_time(69_802_701 as u64) - // Standard Error: 744 - .saturating_add(Weight::from_ref_time(1_334_601 as u64).saturating_mul(r as u64)) + // Minimum execution time: 613 nanoseconds. + Weight::from_ref_time(819_503 as u64) + // Standard Error: 704 + .saturating_add(Weight::from_ref_time(518_031 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 69_052 nanoseconds. - Weight::from_ref_time(69_717_748 as u64) - // Standard Error: 571 - .saturating_add(Weight::from_ref_time(1_346_564 as u64).saturating_mul(r as u64)) + // Minimum execution time: 647 nanoseconds. + Weight::from_ref_time(922_130 as u64) + // Standard Error: 384 + .saturating_add(Weight::from_ref_time(525_187 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 69_016 nanoseconds. - Weight::from_ref_time(69_793_413 as u64) - // Standard Error: 769 - .saturating_add(Weight::from_ref_time(1_317_502 as u64).saturating_mul(r as u64)) + // Minimum execution time: 592 nanoseconds. + Weight::from_ref_time(930_340 as u64) + // Standard Error: 277 + .saturating_add(Weight::from_ref_time(505_104 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 69_043 nanoseconds. - Weight::from_ref_time(69_963_419 as u64) - // Standard Error: 1_117 - .saturating_add(Weight::from_ref_time(1_313_727 as u64).saturating_mul(r as u64)) + // Minimum execution time: 661 nanoseconds. + Weight::from_ref_time(942_938 as u64) + // Standard Error: 268 + .saturating_add(Weight::from_ref_time(504_997 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 69_032 nanoseconds. - Weight::from_ref_time(69_727_577 as u64) - // Standard Error: 662 - .saturating_add(Weight::from_ref_time(1_331_088 as u64).saturating_mul(r as u64)) + // Minimum execution time: 613 nanoseconds. + Weight::from_ref_time(864_875 as u64) + // Standard Error: 720 + .saturating_add(Weight::from_ref_time(508_015 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 69_097 nanoseconds. - Weight::from_ref_time(69_767_650 as u64) - // Standard Error: 2_056 - .saturating_add(Weight::from_ref_time(1_875_021 as u64).saturating_mul(r as u64)) + // Minimum execution time: 609 nanoseconds. + Weight::from_ref_time(964_975 as u64) + // Standard Error: 508 + .saturating_add(Weight::from_ref_time(732_494 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 69_153 nanoseconds. - Weight::from_ref_time(69_906_946 as u64) - // Standard Error: 1_060 - .saturating_add(Weight::from_ref_time(1_867_154 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(991_551 as u64) + // Standard Error: 1_126 + .saturating_add(Weight::from_ref_time(731_593 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 70_380 nanoseconds. - Weight::from_ref_time(69_867_328 as u64) - // Standard Error: 778 - .saturating_add(Weight::from_ref_time(1_869_718 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(938_821 as u64) + // Standard Error: 535 + .saturating_add(Weight::from_ref_time(741_527 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 69_259 nanoseconds. - Weight::from_ref_time(69_695_407 as u64) - // Standard Error: 746 - .saturating_add(Weight::from_ref_time(1_874_772 as u64).saturating_mul(r as u64)) + // Minimum execution time: 634 nanoseconds. + Weight::from_ref_time(969_389 as u64) + // Standard Error: 421 + .saturating_add(Weight::from_ref_time(743_647 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 68_986 nanoseconds. - Weight::from_ref_time(70_027_081 as u64) - // Standard Error: 1_401 - .saturating_add(Weight::from_ref_time(1_862_971 as u64).saturating_mul(r as u64)) + // Minimum execution time: 620 nanoseconds. + Weight::from_ref_time(997_361 as u64) + // Standard Error: 540 + .saturating_add(Weight::from_ref_time(748_108 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 68_953 nanoseconds. - Weight::from_ref_time(69_798_073 as u64) - // Standard Error: 1_000 - .saturating_add(Weight::from_ref_time(1_871_888 as u64).saturating_mul(r as u64)) + // Minimum execution time: 586 nanoseconds. + Weight::from_ref_time(966_929 as u64) + // Standard Error: 524 + .saturating_add(Weight::from_ref_time(760_077 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 68_909 nanoseconds. - Weight::from_ref_time(69_845_981 as u64) - // Standard Error: 775 - .saturating_add(Weight::from_ref_time(1_868_722 as u64).saturating_mul(r as u64)) + // Minimum execution time: 623 nanoseconds. + Weight::from_ref_time(974_811 as u64) + // Standard Error: 528 + .saturating_add(Weight::from_ref_time(745_124 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 68_986 nanoseconds. - Weight::from_ref_time(69_683_189 as u64) - // Standard Error: 503 - .saturating_add(Weight::from_ref_time(1_884_715 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(990_326 as u64) + // Standard Error: 535 + .saturating_add(Weight::from_ref_time(808_599 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 69_230 nanoseconds. - Weight::from_ref_time(69_765_336 as u64) - // Standard Error: 2_060 - .saturating_add(Weight::from_ref_time(1_871_848 as u64).saturating_mul(r as u64)) + // Minimum execution time: 600 nanoseconds. + Weight::from_ref_time(969_957 as u64) + // Standard Error: 604 + .saturating_add(Weight::from_ref_time(744_174 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 68_953 nanoseconds. - Weight::from_ref_time(69_828_265 as u64) - // Standard Error: 951 - .saturating_add(Weight::from_ref_time(1_868_596 as u64).saturating_mul(r as u64)) + // Minimum execution time: 632 nanoseconds. + Weight::from_ref_time(976_250 as u64) + // Standard Error: 938 + .saturating_add(Weight::from_ref_time(798_224 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 69_078 nanoseconds. - Weight::from_ref_time(69_832_768 as u64) - // Standard Error: 894 - .saturating_add(Weight::from_ref_time(1_845_786 as u64).saturating_mul(r as u64)) + // Minimum execution time: 627 nanoseconds. + Weight::from_ref_time(939_131 as u64) + // Standard Error: 457 + .saturating_add(Weight::from_ref_time(718_514 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 68_939 nanoseconds. - Weight::from_ref_time(69_676_256 as u64) - // Standard Error: 374 - .saturating_add(Weight::from_ref_time(1_851_026 as u64).saturating_mul(r as u64)) + // Minimum execution time: 621 nanoseconds. + Weight::from_ref_time(905_432 as u64) + // Standard Error: 637 + .saturating_add(Weight::from_ref_time(716_365 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 69_096 nanoseconds. - Weight::from_ref_time(69_914_159 as u64) - // Standard Error: 1_265 - .saturating_add(Weight::from_ref_time(1_844_489 as u64).saturating_mul(r as u64)) + // Minimum execution time: 610 nanoseconds. + Weight::from_ref_time(926_074 as u64) + // Standard Error: 457 + .saturating_add(Weight::from_ref_time(716_003 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 68_939 nanoseconds. - Weight::from_ref_time(69_641_768 as u64) - // Standard Error: 347 - .saturating_add(Weight::from_ref_time(2_488_628 as u64).saturating_mul(r as u64)) + // Minimum execution time: 595 nanoseconds. + Weight::from_ref_time(1_023_054 as u64) + // Standard Error: 2_584 + .saturating_add(Weight::from_ref_time(1_349_736 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 69_114 nanoseconds. - Weight::from_ref_time(69_844_395 as u64) - // Standard Error: 1_489 - .saturating_add(Weight::from_ref_time(2_456_310 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(966_937 as u64) + // Standard Error: 786 + .saturating_add(Weight::from_ref_time(1_284_291 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 69_082 nanoseconds. - Weight::from_ref_time(69_993_662 as u64) - // Standard Error: 1_218 - .saturating_add(Weight::from_ref_time(2_524_010 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(972_082 as u64) + // Standard Error: 1_441 + .saturating_add(Weight::from_ref_time(1_403_148 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 69_036 nanoseconds. - Weight::from_ref_time(70_095_304 as u64) - // Standard Error: 1_473 - .saturating_add(Weight::from_ref_time(2_429_659 as u64).saturating_mul(r as u64)) + // Minimum execution time: 644 nanoseconds. + Weight::from_ref_time(991_706 as u64) + // Standard Error: 1_103 + .saturating_add(Weight::from_ref_time(1_284_545 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 69_229 nanoseconds. - Weight::from_ref_time(69_759_818 as u64) - // Standard Error: 573 - .saturating_add(Weight::from_ref_time(1_879_670 as u64).saturating_mul(r as u64)) + // Minimum execution time: 630 nanoseconds. + Weight::from_ref_time(941_587 as u64) + // Standard Error: 506 + .saturating_add(Weight::from_ref_time(719_943 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 69_151 nanoseconds. - Weight::from_ref_time(69_865_948 as u64) - // Standard Error: 721 - .saturating_add(Weight::from_ref_time(1_846_734 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(939_991 as u64) + // Standard Error: 520 + .saturating_add(Weight::from_ref_time(719_994 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 69_120 nanoseconds. - Weight::from_ref_time(70_135_849 as u64) - // Standard Error: 3_443 - .saturating_add(Weight::from_ref_time(1_841_784 as u64).saturating_mul(r as u64)) + // Minimum execution time: 609 nanoseconds. + Weight::from_ref_time(970_308 as u64) + // Standard Error: 552 + .saturating_add(Weight::from_ref_time(719_566 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 69_077 nanoseconds. - Weight::from_ref_time(69_929_746 as u64) - // Standard Error: 821 - .saturating_add(Weight::from_ref_time(1_866_348 as u64).saturating_mul(r as u64)) + // Minimum execution time: 613 nanoseconds. + Weight::from_ref_time(920_835 as u64) + // Standard Error: 623 + .saturating_add(Weight::from_ref_time(737_690 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 69_226 nanoseconds. - Weight::from_ref_time(69_725_630 as u64) - // Standard Error: 891 - .saturating_add(Weight::from_ref_time(1_873_637 as u64).saturating_mul(r as u64)) + // Minimum execution time: 626 nanoseconds. + Weight::from_ref_time(919_030 as u64) + // Standard Error: 486 + .saturating_add(Weight::from_ref_time(737_096 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 70_591 nanoseconds. - Weight::from_ref_time(69_939_773 as u64) - // Standard Error: 960 - .saturating_add(Weight::from_ref_time(1_867_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 634 nanoseconds. + Weight::from_ref_time(964_779 as u64) + // Standard Error: 496 + .saturating_add(Weight::from_ref_time(736_322 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 69_187 nanoseconds. - Weight::from_ref_time(69_845_516 as u64) - // Standard Error: 781 - .saturating_add(Weight::from_ref_time(1_869_613 as u64).saturating_mul(r as u64)) + // Minimum execution time: 631 nanoseconds. + Weight::from_ref_time(918_768 as u64) + // Standard Error: 952 + .saturating_add(Weight::from_ref_time(740_280 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 69_065 nanoseconds. - Weight::from_ref_time(69_950_430 as u64) - // Standard Error: 986 - .saturating_add(Weight::from_ref_time(1_867_001 as u64).saturating_mul(r as u64)) + // Minimum execution time: 639 nanoseconds. + Weight::from_ref_time(955_994 as u64) + // Standard Error: 523 + .saturating_add(Weight::from_ref_time(738_232 as u64).saturating_mul(r as u64)) } } @@ -1409,17 +1416,17 @@ impl WeightInfo for SubstrateWeight { impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 3_064 nanoseconds. - Weight::from_ref_time(3_236_000 as u64) + // Minimum execution time: 3_092 nanoseconds. + Weight::from_ref_time(3_273_000 as u64) .saturating_add(RocksDbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 15_492 nanoseconds. - Weight::from_ref_time(14_309_233 as u64) - // Standard Error: 649 - .saturating_add(Weight::from_ref_time(930_078 as u64).saturating_mul(k as u64)) + // Minimum execution time: 15_553 nanoseconds. + Weight::from_ref_time(17_898_219 as u64) + // Standard Error: 612 + .saturating_add(Weight::from_ref_time(959_535 as u64).saturating_mul(k as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) .saturating_add(RocksDbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -1427,10 +1434,10 @@ impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 3_240 nanoseconds. - Weight::from_ref_time(15_076_559 as u64) - // Standard Error: 3_337 - .saturating_add(Weight::from_ref_time(1_244_348 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_051 nanoseconds. + Weight::from_ref_time(16_045_885 as u64) + // Standard Error: 3_894 + .saturating_add(Weight::from_ref_time(1_251_095 as u64).saturating_mul(q as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1438,10 +1445,10 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 22_524 nanoseconds. - Weight::from_ref_time(19_939_078 as u64) - // Standard Error: 43 - .saturating_add(Weight::from_ref_time(43_802 as u64).saturating_mul(c as u64)) + // Minimum execution time: 29_767 nanoseconds. + Weight::from_ref_time(24_442_384 as u64) + // Standard Error: 41 + .saturating_add(Weight::from_ref_time(47_060 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1452,10 +1459,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 261_039 nanoseconds. - Weight::from_ref_time(228_709_853 as u64) - // Standard Error: 105 - .saturating_add(Weight::from_ref_time(47_449 as u64).saturating_mul(c as u64)) + // Minimum execution time: 307_279 nanoseconds. + Weight::from_ref_time(317_807_474 as u64) + // Standard Error: 17 + .saturating_add(Weight::from_ref_time(30_874 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1470,12 +1477,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_054_867 nanoseconds. - Weight::from_ref_time(259_090_306 as u64) - // Standard Error: 72 - .saturating_add(Weight::from_ref_time(107_519 as u64).saturating_mul(c as u64)) - // Standard Error: 4 - .saturating_add(Weight::from_ref_time(1_736 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_173_376 nanoseconds. + Weight::from_ref_time(333_991_198 as u64) + // Standard Error: 47 + .saturating_add(Weight::from_ref_time(90_283 as u64).saturating_mul(c as u64)) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_782 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(9 as u64)) } @@ -1488,10 +1495,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 213_409 nanoseconds. - Weight::from_ref_time(205_300_495 as u64) + // Minimum execution time: 187_549 nanoseconds. + Weight::from_ref_time(176_268_968 as u64) // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_479 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_525 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(7 as u64)) } @@ -1501,8 +1508,8 @@ impl WeightInfo for () { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 183_317 nanoseconds. - Weight::from_ref_time(184_465_000 as u64) + // Minimum execution time: 156_476 nanoseconds. + Weight::from_ref_time(157_462_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1512,10 +1519,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 56_187 nanoseconds. - Weight::from_ref_time(60_636_621 as u64) - // Standard Error: 46 - .saturating_add(Weight::from_ref_time(45_734 as u64).saturating_mul(c as u64)) + // Minimum execution time: 295_320 nanoseconds. + Weight::from_ref_time(305_011_007 as u64) + // Standard Error: 53 + .saturating_add(Weight::from_ref_time(77_528 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1524,8 +1531,8 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 38_433 nanoseconds. - Weight::from_ref_time(38_917_000 as u64) + // Minimum execution time: 39_868 nanoseconds. + Weight::from_ref_time(40_885_000 as u64) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1533,8 +1540,8 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 41_507 nanoseconds. - Weight::from_ref_time(41_938_000 as u64) + // Minimum execution time: 42_082 nanoseconds. + Weight::from_ref_time(42_487_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(6 as u64)) } @@ -1545,10 +1552,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 249_628 nanoseconds. - Weight::from_ref_time(251_997_923 as u64) - // Standard Error: 26_157 - .saturating_add(Weight::from_ref_time(35_002_004 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_276 nanoseconds. + Weight::from_ref_time(300_528_395 as u64) + // Standard Error: 22_438 + .saturating_add(Weight::from_ref_time(16_661_252 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1559,10 +1566,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 249_390 nanoseconds. - Weight::from_ref_time(193_793_052 as u64) - // Standard Error: 430_292 - .saturating_add(Weight::from_ref_time(211_029_686 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_022 nanoseconds. + Weight::from_ref_time(231_263_577 as u64) + // Standard Error: 430_945 + .saturating_add(Weight::from_ref_time(199_389_344 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1574,10 +1581,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 252_469 nanoseconds. - Weight::from_ref_time(201_438_856 as u64) - // Standard Error: 420_040 - .saturating_add(Weight::from_ref_time(267_340_744 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_796 nanoseconds. + Weight::from_ref_time(243_158_249 as u64) + // Standard Error: 396_560 + .saturating_add(Weight::from_ref_time(242_784_462 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1589,10 +1596,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 251_154 nanoseconds. - Weight::from_ref_time(254_831_062 as u64) - // Standard Error: 37_843 - .saturating_add(Weight::from_ref_time(38_579_567 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_206 nanoseconds. + Weight::from_ref_time(302_423_708 as u64) + // Standard Error: 18_660 + .saturating_add(Weight::from_ref_time(20_507_825 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1603,10 +1610,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 247_875 nanoseconds. - Weight::from_ref_time(250_312_587 as u64) - // Standard Error: 17_901 - .saturating_add(Weight::from_ref_time(15_153_431 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_337 nanoseconds. + Weight::from_ref_time(298_462_585 as u64) + // Standard Error: 15_979 + .saturating_add(Weight::from_ref_time(11_165_786 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1617,10 +1624,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 250_097 nanoseconds. - Weight::from_ref_time(252_157_442 as u64) - // Standard Error: 38_426 - .saturating_add(Weight::from_ref_time(35_084_205 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_982 nanoseconds. + Weight::from_ref_time(299_538_930 as u64) + // Standard Error: 18_777 + .saturating_add(Weight::from_ref_time(16_575_318 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1631,10 +1638,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 250_034 nanoseconds. - Weight::from_ref_time(252_189_233 as u64) - // Standard Error: 33_081 - .saturating_add(Weight::from_ref_time(34_764_160 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_266 nanoseconds. + Weight::from_ref_time(301_023_294 as u64) + // Standard Error: 18_987 + .saturating_add(Weight::from_ref_time(16_152_668 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1645,10 +1652,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 249_587 nanoseconds. - Weight::from_ref_time(258_565_111 as u64) - // Standard Error: 75_715 - .saturating_add(Weight::from_ref_time(109_687_486 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_847 nanoseconds. + Weight::from_ref_time(302_991_846 as u64) + // Standard Error: 36_830 + .saturating_add(Weight::from_ref_time(89_091_598 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1659,10 +1666,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 249_735 nanoseconds. - Weight::from_ref_time(252_875_784 as u64) - // Standard Error: 42_024 - .saturating_add(Weight::from_ref_time(34_555_983 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_907 nanoseconds. + Weight::from_ref_time(300_322_285 as u64) + // Standard Error: 20_612 + .saturating_add(Weight::from_ref_time(16_199_834 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1673,10 +1680,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 250_025 nanoseconds. - Weight::from_ref_time(255_212_046 as u64) - // Standard Error: 41_865 - .saturating_add(Weight::from_ref_time(34_332_291 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_042 nanoseconds. + Weight::from_ref_time(299_750_507 as u64) + // Standard Error: 19_981 + .saturating_add(Weight::from_ref_time(16_290_215 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1687,10 +1694,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 247_641 nanoseconds. - Weight::from_ref_time(252_978_686 as u64) - // Standard Error: 25_820 - .saturating_add(Weight::from_ref_time(34_175_386 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_129 nanoseconds. + Weight::from_ref_time(301_389_224 as u64) + // Standard Error: 20_956 + .saturating_add(Weight::from_ref_time(15_947_448 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1701,10 +1708,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 249_871 nanoseconds. - Weight::from_ref_time(253_237_931 as u64) - // Standard Error: 30_986 - .saturating_add(Weight::from_ref_time(34_305_155 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_128 nanoseconds. + Weight::from_ref_time(299_569_582 as u64) + // Standard Error: 18_853 + .saturating_add(Weight::from_ref_time(16_304_774 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1716,10 +1723,10 @@ impl WeightInfo for () { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 249_787 nanoseconds. - Weight::from_ref_time(258_457_094 as u64) - // Standard Error: 75_835 - .saturating_add(Weight::from_ref_time(107_115_666 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_229 nanoseconds. + Weight::from_ref_time(305_986_569 as u64) + // Standard Error: 33_339 + .saturating_add(Weight::from_ref_time(85_497_208 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1730,10 +1737,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 171_667 nanoseconds. - Weight::from_ref_time(174_687_863 as u64) - // Standard Error: 34_576 - .saturating_add(Weight::from_ref_time(15_895_674 as u64).saturating_mul(r as u64)) + // Minimum execution time: 144_560 nanoseconds. + Weight::from_ref_time(147_780_996 as u64) + // Standard Error: 8_658 + .saturating_add(Weight::from_ref_time(8_185_717 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1744,10 +1751,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 249_610 nanoseconds. - Weight::from_ref_time(251_476_758 as u64) - // Standard Error: 39_422 - .saturating_add(Weight::from_ref_time(32_870_429 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_869 nanoseconds. + Weight::from_ref_time(300_501_085 as u64) + // Standard Error: 17_955 + .saturating_add(Weight::from_ref_time(13_899_691 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1758,10 +1765,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 285_154 nanoseconds. - Weight::from_ref_time(307_768_636 as u64) - // Standard Error: 2_701 - .saturating_add(Weight::from_ref_time(9_544_122 as u64).saturating_mul(n as u64)) + // Minimum execution time: 312_247 nanoseconds. + Weight::from_ref_time(327_623_543 as u64) + // Standard Error: 1_162 + .saturating_add(Weight::from_ref_time(9_752_573 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1772,10 +1779,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 244_810 nanoseconds. - Weight::from_ref_time(247_576_385 as u64) - // Standard Error: 80_494 - .saturating_add(Weight::from_ref_time(2_052_714 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_105 nanoseconds. + Weight::from_ref_time(296_353_112 as u64) + // Standard Error: 558_302 + .saturating_add(Weight::from_ref_time(1_012_487 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1786,10 +1793,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 248_049 nanoseconds. - Weight::from_ref_time(250_148_025 as u64) - // Standard Error: 339 - .saturating_add(Weight::from_ref_time(185_344 as u64).saturating_mul(n as u64)) + // Minimum execution time: 295_097 nanoseconds. + Weight::from_ref_time(298_173_380 as u64) + // Standard Error: 325 + .saturating_add(Weight::from_ref_time(191_050 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1802,10 +1809,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 246_620 nanoseconds. - Weight::from_ref_time(250_752_277 as u64) - // Standard Error: 84_300 - .saturating_add(Weight::from_ref_time(54_264_722 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_339 nanoseconds. + Weight::from_ref_time(297_328_822 as u64) + // Standard Error: 536_109 + .saturating_add(Weight::from_ref_time(53_529_277 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1819,10 +1826,10 @@ impl WeightInfo for () { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 249_065 nanoseconds. - Weight::from_ref_time(252_419_902 as u64) - // Standard Error: 84_223 - .saturating_add(Weight::from_ref_time(134_454_079 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_833 nanoseconds. + Weight::from_ref_time(303_220_868 as u64) + // Standard Error: 46_963 + .saturating_add(Weight::from_ref_time(108_698_031 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1833,10 +1840,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 246_588 nanoseconds. - Weight::from_ref_time(261_525_328 as u64) - // Standard Error: 97_732 - .saturating_add(Weight::from_ref_time(235_555_878 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_111 nanoseconds. + Weight::from_ref_time(304_357_752 as u64) + // Standard Error: 84_942 + .saturating_add(Weight::from_ref_time(218_943_695 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1848,12 +1855,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_171_144 nanoseconds. - Weight::from_ref_time(490_333_337 as u64) - // Standard Error: 404_664 - .saturating_add(Weight::from_ref_time(173_683_265 as u64).saturating_mul(t as u64)) - // Standard Error: 111_140 - .saturating_add(Weight::from_ref_time(66_081_822 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_188_981 nanoseconds. + Weight::from_ref_time(494_557_508 as u64) + // Standard Error: 335_039 + .saturating_add(Weight::from_ref_time(176_656_427 as u64).saturating_mul(t as u64)) + // Standard Error: 92_018 + .saturating_add(Weight::from_ref_time(70_000_320 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1866,20 +1873,20 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 178_822 nanoseconds. - Weight::from_ref_time(181_571_518 as u64) - // Standard Error: 19_207 - .saturating_add(Weight::from_ref_time(26_784_712 as u64).saturating_mul(r as u64)) + // Minimum execution time: 157_568 nanoseconds. + Weight::from_ref_time(161_449_917 as u64) + // Standard Error: 13_938 + .saturating_add(Weight::from_ref_time(12_897_245 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 249_737 nanoseconds. - Weight::from_ref_time(208_095_467 as u64) - // Standard Error: 417_236 - .saturating_add(Weight::from_ref_time(430_088_574 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_001 nanoseconds. + Weight::from_ref_time(248_958_000 as u64) + // Standard Error: 472_012 + .saturating_add(Weight::from_ref_time(418_368_781 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1888,10 +1895,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 400_055 nanoseconds. - Weight::from_ref_time(551_666_883 as u64) - // Standard Error: 1_379_652 - .saturating_add(Weight::from_ref_time(94_069_118 as u64).saturating_mul(n as u64)) + // Minimum execution time: 433_239 nanoseconds. + Weight::from_ref_time(588_857_373 as u64) + // Standard Error: 1_426_031 + .saturating_add(Weight::from_ref_time(92_895_050 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(52 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(50 as u64)) @@ -1900,10 +1907,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 400_370 nanoseconds. - Weight::from_ref_time(521_380_000 as u64) - // Standard Error: 1_112_618 - .saturating_add(Weight::from_ref_time(68_664_898 as u64).saturating_mul(n as u64)) + // Minimum execution time: 432_591 nanoseconds. + Weight::from_ref_time(563_499_766 as u64) + // Standard Error: 1_212_322 + .saturating_add(Weight::from_ref_time(65_491_920 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(49 as u64)) @@ -1912,10 +1919,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 249_711 nanoseconds. - Weight::from_ref_time(212_629_798 as u64) - // Standard Error: 378_159 - .saturating_add(Weight::from_ref_time(415_326_230 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_678 nanoseconds. + Weight::from_ref_time(250_903_819 as u64) + // Standard Error: 483_469 + .saturating_add(Weight::from_ref_time(410_221_708 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1924,10 +1931,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 365_702 nanoseconds. - Weight::from_ref_time(499_337_686 as u64) - // Standard Error: 1_232_330 - .saturating_add(Weight::from_ref_time(70_648_878 as u64).saturating_mul(n as u64)) + // Minimum execution time: 401_147 nanoseconds. + Weight::from_ref_time(547_029_800 as u64) + // Standard Error: 1_350_158 + .saturating_add(Weight::from_ref_time(66_946_722 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -1936,10 +1943,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 251_357 nanoseconds. - Weight::from_ref_time(220_533_580 as u64) - // Standard Error: 345_297 - .saturating_add(Weight::from_ref_time(349_413_968 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_061 nanoseconds. + Weight::from_ref_time(257_651_770 as u64) + // Standard Error: 444_344 + .saturating_add(Weight::from_ref_time(329_428_375 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1947,10 +1954,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 354_162 nanoseconds. - Weight::from_ref_time(472_811_575 as u64) - // Standard Error: 1_109_282 - .saturating_add(Weight::from_ref_time(154_074_386 as u64).saturating_mul(n as u64)) + // Minimum execution time: 377_320 nanoseconds. + Weight::from_ref_time(506_517_859 as u64) + // Standard Error: 1_210_985 + .saturating_add(Weight::from_ref_time(154_977_621 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1958,10 +1965,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 247_551 nanoseconds. - Weight::from_ref_time(219_176_526 as u64) - // Standard Error: 358_914 - .saturating_add(Weight::from_ref_time(326_009_513 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_753 nanoseconds. + Weight::from_ref_time(260_829_553 as u64) + // Standard Error: 432_834 + .saturating_add(Weight::from_ref_time(317_967_995 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1969,10 +1976,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 339_149 nanoseconds. - Weight::from_ref_time(440_615_016 as u64) - // Standard Error: 954_837 - .saturating_add(Weight::from_ref_time(66_153_533 as u64).saturating_mul(n as u64)) + // Minimum execution time: 373_049 nanoseconds. + Weight::from_ref_time(484_443_595 as u64) + // Standard Error: 1_048_752 + .saturating_add(Weight::from_ref_time(64_192_391 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1980,10 +1987,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 251_812 nanoseconds. - Weight::from_ref_time(209_954_069 as u64) - // Standard Error: 398_380 - .saturating_add(Weight::from_ref_time(438_573_954 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_893 nanoseconds. + Weight::from_ref_time(256_830_685 as u64) + // Standard Error: 436_220 + .saturating_add(Weight::from_ref_time(418_336_409 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1992,10 +1999,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 374_594 nanoseconds. - Weight::from_ref_time(525_213_792 as u64) - // Standard Error: 1_378_489 - .saturating_add(Weight::from_ref_time(161_599_623 as u64).saturating_mul(n as u64)) + // Minimum execution time: 402_327 nanoseconds. + Weight::from_ref_time(562_732_190 as u64) + // Standard Error: 1_453_818 + .saturating_add(Weight::from_ref_time(159_662_683 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -2008,10 +2015,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 251_379 nanoseconds. - Weight::from_ref_time(204_214_298 as u64) - // Standard Error: 662_575 - .saturating_add(Weight::from_ref_time(1_366_716_853 as u64).saturating_mul(r as u64)) + // Minimum execution time: 298_014 nanoseconds. + Weight::from_ref_time(248_052_379 as u64) + // Standard Error: 595_597 + .saturating_add(Weight::from_ref_time(1_341_846_920 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(4 as u64)) @@ -2024,10 +2031,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 252_896 nanoseconds. - Weight::from_ref_time(253_811_000 as u64) - // Standard Error: 6_576_179 - .saturating_add(Weight::from_ref_time(17_254_952_849 as u64).saturating_mul(r as u64)) + // Minimum execution time: 298_250 nanoseconds. + Weight::from_ref_time(299_254_000 as u64) + // Standard Error: 8_061_285 + .saturating_add(Weight::from_ref_time(21_176_072_564 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2040,10 +2047,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 249_312 nanoseconds. - Weight::from_ref_time(253_806_000 as u64) - // Standard Error: 6_118_873 - .saturating_add(Weight::from_ref_time(17_081_370_212 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_286 nanoseconds. + Weight::from_ref_time(505_420_101 as u64) + // Standard Error: 12_020_807 + .saturating_add(Weight::from_ref_time(20_502_779_430 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2057,12 +2064,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 12_001_522 nanoseconds. - Weight::from_ref_time(10_903_312_955 as u64) - // Standard Error: 4_301_096 - .saturating_add(Weight::from_ref_time(1_243_413_241 as u64).saturating_mul(t as u64)) - // Standard Error: 6_449 - .saturating_add(Weight::from_ref_time(9_713_655 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_465_740 nanoseconds. + Weight::from_ref_time(8_443_609_945 as u64) + // Standard Error: 6_130_641 + .saturating_add(Weight::from_ref_time(1_269_904_453 as u64).saturating_mul(t as u64)) + // Standard Error: 9_192 + .saturating_add(Weight::from_ref_time(9_821_368 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(167 as u64)) .saturating_add(RocksDbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(163 as u64)) @@ -2077,10 +2084,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 254_969 nanoseconds. - Weight::from_ref_time(255_984_000 as u64) - // Standard Error: 18_545_048 - .saturating_add(Weight::from_ref_time(22_343_189_765 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_708 nanoseconds. + Weight::from_ref_time(294_333_000 as u64) + // Standard Error: 19_087_339 + .saturating_add(Weight::from_ref_time(25_796_470_079 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(5 as u64)) @@ -2096,10 +2103,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 14_077_497 nanoseconds. - Weight::from_ref_time(13_949_740_588 as u64) - // Standard Error: 66_631 - .saturating_add(Weight::from_ref_time(120_519_572 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_500_978 nanoseconds. + Weight::from_ref_time(11_033_266_932 as u64) + // Standard Error: 48_183_801 + .saturating_add(Weight::from_ref_time(36_156_854 as u64).saturating_mul(t as u64)) + // Standard Error: 77_067 + .saturating_add(Weight::from_ref_time(122_691_370 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(249 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(247 as u64)) @@ -2112,10 +2121,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 247_445 nanoseconds. - Weight::from_ref_time(251_229_791 as u64) - // Standard Error: 88_045 - .saturating_add(Weight::from_ref_time(57_577_008 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_534 nanoseconds. + Weight::from_ref_time(292_978_777 as u64) + // Standard Error: 612_499 + .saturating_add(Weight::from_ref_time(41_539_022 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2126,10 +2135,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 308_069 nanoseconds. - Weight::from_ref_time(308_971_000 as u64) - // Standard Error: 46_181 - .saturating_add(Weight::from_ref_time(321_835_684 as u64).saturating_mul(n as u64)) + // Minimum execution time: 331_137 nanoseconds. + Weight::from_ref_time(332_503_000 as u64) + // Standard Error: 56_729 + .saturating_add(Weight::from_ref_time(325_461_347 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2140,10 +2149,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 247_107 nanoseconds. - Weight::from_ref_time(250_125_030 as u64) - // Standard Error: 88_769 - .saturating_add(Weight::from_ref_time(70_727_669 as u64).saturating_mul(r as u64)) + // Minimum execution time: 288_957 nanoseconds. + Weight::from_ref_time(292_957_579 as u64) + // Standard Error: 636_977 + .saturating_add(Weight::from_ref_time(60_789_720 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2154,10 +2163,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 319_515 nanoseconds. - Weight::from_ref_time(319_784_000 as u64) - // Standard Error: 58_896 - .saturating_add(Weight::from_ref_time(246_433_962 as u64).saturating_mul(n as u64)) + // Minimum execution time: 343_123 nanoseconds. + Weight::from_ref_time(343_741_000 as u64) + // Standard Error: 58_203 + .saturating_add(Weight::from_ref_time(247_808_004 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2168,10 +2177,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 247_887 nanoseconds. - Weight::from_ref_time(250_452_702 as u64) - // Standard Error: 140_887 - .saturating_add(Weight::from_ref_time(49_538_397 as u64).saturating_mul(r as u64)) + // Minimum execution time: 286_493 nanoseconds. + Weight::from_ref_time(293_256_030 as u64) + // Standard Error: 608_271 + .saturating_add(Weight::from_ref_time(31_193_669 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2182,10 +2191,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 297_534 nanoseconds. - Weight::from_ref_time(298_249_000 as u64) - // Standard Error: 49_680 - .saturating_add(Weight::from_ref_time(99_001_103 as u64).saturating_mul(n as u64)) + // Minimum execution time: 321_692 nanoseconds. + Weight::from_ref_time(322_518_000 as u64) + // Standard Error: 50_856 + .saturating_add(Weight::from_ref_time(99_851_120 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2196,10 +2205,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 245_926 nanoseconds. - Weight::from_ref_time(248_471_834 as u64) - // Standard Error: 101_639 - .saturating_add(Weight::from_ref_time(47_889_865 as u64).saturating_mul(r as u64)) + // Minimum execution time: 285_829 nanoseconds. + Weight::from_ref_time(291_929_059 as u64) + // Standard Error: 609_982 + .saturating_add(Weight::from_ref_time(30_437_840 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2210,10 +2219,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 294_835 nanoseconds. - Weight::from_ref_time(296_328_000 as u64) - // Standard Error: 46_612 - .saturating_add(Weight::from_ref_time(98_859_152 as u64).saturating_mul(n as u64)) + // Minimum execution time: 320_218 nanoseconds. + Weight::from_ref_time(320_820_000 as u64) + // Standard Error: 49_721 + .saturating_add(Weight::from_ref_time(99_723_926 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2224,10 +2233,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 251_104 nanoseconds. - Weight::from_ref_time(253_114_893 as u64) - // Standard Error: 316_740 - .saturating_add(Weight::from_ref_time(2_964_072_706 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_068 nanoseconds. + Weight::from_ref_time(294_064_673 as u64) + // Standard Error: 818_242 + .saturating_add(Weight::from_ref_time(3_038_409_926 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2238,10 +2247,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 250_048 nanoseconds. - Weight::from_ref_time(251_774_991 as u64) - // Standard Error: 115_294 - .saturating_add(Weight::from_ref_time(2_094_245_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_271 nanoseconds. + Weight::from_ref_time(293_100_328 as u64) + // Standard Error: 658_900 + .saturating_add(Weight::from_ref_time(2_070_519_571 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2253,10 +2262,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 250_830 nanoseconds. - Weight::from_ref_time(251_477_000 as u64) - // Standard Error: 2_727_998 - .saturating_add(Weight::from_ref_time(1_390_149_283 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_181 nanoseconds. + Weight::from_ref_time(290_618_000 as u64) + // Standard Error: 2_652_670 + .saturating_add(Weight::from_ref_time(1_362_797_408 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2266,381 +2275,385 @@ impl WeightInfo for () { // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) + // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_reentrant_count(r: u32, ) -> Weight { - Weight::from_ref_time(304_709_000 as u64) - // Standard Error: 67_000 - .saturating_add(Weight::from_ref_time(15_411_000 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(4 as u64)) - .saturating_add(RocksDbWeight::get().writes(1 as u64)) + fn reentrant_count(r: u32, ) -> Weight { + // Minimum execution time: 290_954 nanoseconds. + Weight::from_ref_time(295_190_436 as u64) + // Standard Error: 40_295 + .saturating_add(Weight::from_ref_time(11_022_974 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(6 as u64)) + .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) + // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { - Weight::from_ref_time(328_378_000 as u64) - // Standard Error: 137_000 - .saturating_add(Weight::from_ref_time(37_448_000 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(4 as u64)) - .saturating_add(RocksDbWeight::get().writes(1 as u64)) + fn account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 292_817 nanoseconds. + Weight::from_ref_time(331_195_835 as u64) + // Standard Error: 126_642 + .saturating_add(Weight::from_ref_time(25_590_472 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(6 as u64)) + .saturating_add(RocksDbWeight::get().writes(3 as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 69_022 nanoseconds. - Weight::from_ref_time(69_707_657 as u64) - // Standard Error: 8_674 - .saturating_add(Weight::from_ref_time(887_555 as u64).saturating_mul(r as u64)) + // Minimum execution time: 605 nanoseconds. + Weight::from_ref_time(866_109 as u64) + // Standard Error: 275 + .saturating_add(Weight::from_ref_time(346_136 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 69_491 nanoseconds. - Weight::from_ref_time(70_354_670 as u64) - // Standard Error: 1_518 - .saturating_add(Weight::from_ref_time(2_758_912 as u64).saturating_mul(r as u64)) + // Minimum execution time: 718 nanoseconds. + Weight::from_ref_time(1_402_372 as u64) + // Standard Error: 2_693 + .saturating_add(Weight::from_ref_time(985_910 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 69_156 nanoseconds. - Weight::from_ref_time(69_917_601 as u64) - // Standard Error: 1_970 - .saturating_add(Weight::from_ref_time(2_753_174 as u64).saturating_mul(r as u64)) + // Minimum execution time: 706 nanoseconds. + Weight::from_ref_time(1_120_197 as u64) + // Standard Error: 394 + .saturating_add(Weight::from_ref_time(889_593 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 68_944 nanoseconds. - Weight::from_ref_time(69_727_961 as u64) - // Standard Error: 376 - .saturating_add(Weight::from_ref_time(2_356_996 as u64).saturating_mul(r as u64)) + // Minimum execution time: 644 nanoseconds. + Weight::from_ref_time(1_057_422 as u64) + // Standard Error: 857 + .saturating_add(Weight::from_ref_time(955_777 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 68_971 nanoseconds. - Weight::from_ref_time(69_755_949 as u64) - // Standard Error: 543 - .saturating_add(Weight::from_ref_time(2_489_510 as u64).saturating_mul(r as u64)) + // Minimum execution time: 637 nanoseconds. + Weight::from_ref_time(629_141 as u64) + // Standard Error: 544 + .saturating_add(Weight::from_ref_time(1_293_126 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 69_061 nanoseconds. - Weight::from_ref_time(69_625_000 as u64) - // Standard Error: 486 - .saturating_add(Weight::from_ref_time(1_431_684 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(1_113_576 as u64) + // Standard Error: 880 + .saturating_add(Weight::from_ref_time(527_673 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 69_058 nanoseconds. - Weight::from_ref_time(69_521_790 as u64) - // Standard Error: 892 - .saturating_add(Weight::from_ref_time(1_964_054 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(170_717 as u64) + // Standard Error: 1_959 + .saturating_add(Weight::from_ref_time(867_748 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 69_020 nanoseconds. - Weight::from_ref_time(69_344_255 as u64) - // Standard Error: 1_408 - .saturating_add(Weight::from_ref_time(2_169_179 as u64).saturating_mul(r as u64)) + // Minimum execution time: 648 nanoseconds. + Weight::from_ref_time(539_108 as u64) + // Standard Error: 1_490 + .saturating_add(Weight::from_ref_time(1_077_401 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 72_366 nanoseconds. - Weight::from_ref_time(72_869_594 as u64) - // Standard Error: 73 - .saturating_add(Weight::from_ref_time(3_867 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_179 nanoseconds. + Weight::from_ref_time(2_597_080 as u64) + // Standard Error: 74 + .saturating_add(Weight::from_ref_time(4_865 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 69_164 nanoseconds. - Weight::from_ref_time(70_269_099 as u64) - // Standard Error: 8_824 - .saturating_add(Weight::from_ref_time(6_594_634 as u64).saturating_mul(r as u64)) + // Minimum execution time: 633 nanoseconds. + Weight::from_ref_time(1_498_082 as u64) + // Standard Error: 1_780 + .saturating_add(Weight::from_ref_time(2_198_342 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 83_348 nanoseconds. - Weight::from_ref_time(84_968_895 as u64) - // Standard Error: 6_305 - .saturating_add(Weight::from_ref_time(8_395_193 as u64).saturating_mul(r as u64)) + // Minimum execution time: 806 nanoseconds. + Weight::from_ref_time(1_904_912 as u64) + // Standard Error: 1_182 + .saturating_add(Weight::from_ref_time(2_801_959 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 92_358 nanoseconds. - Weight::from_ref_time(93_605_536 as u64) - // Standard Error: 2_019 - .saturating_add(Weight::from_ref_time(536_495 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_219 nanoseconds. + Weight::from_ref_time(5_152_036 as u64) + // Standard Error: 290 + .saturating_add(Weight::from_ref_time(179_507 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 69_191 nanoseconds. - Weight::from_ref_time(70_407_702 as u64) - // Standard Error: 2_812 - .saturating_add(Weight::from_ref_time(901_706 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_438 nanoseconds. + Weight::from_ref_time(1_730_599 as u64) + // Standard Error: 208 + .saturating_add(Weight::from_ref_time(364_842 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 69_230 nanoseconds. - Weight::from_ref_time(70_255_278 as u64) - // Standard Error: 1_284 - .saturating_add(Weight::from_ref_time(951_754 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_430 nanoseconds. + Weight::from_ref_time(1_671_358 as u64) + // Standard Error: 276 + .saturating_add(Weight::from_ref_time(383_715 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 69_278 nanoseconds. - Weight::from_ref_time(70_089_139 as u64) - // Standard Error: 757 - .saturating_add(Weight::from_ref_time(1_369_185 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_394 nanoseconds. + Weight::from_ref_time(1_708_668 as u64) + // Standard Error: 199 + .saturating_add(Weight::from_ref_time(526_648 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 72_047 nanoseconds. - Weight::from_ref_time(72_783_972 as u64) - // Standard Error: 837 - .saturating_add(Weight::from_ref_time(1_471_680 as u64).saturating_mul(r as u64)) + // Minimum execution time: 713 nanoseconds. + Weight::from_ref_time(1_095_871 as u64) + // Standard Error: 343 + .saturating_add(Weight::from_ref_time(811_365 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 71_960 nanoseconds. - Weight::from_ref_time(72_745_981 as u64) - // Standard Error: 1_086 - .saturating_add(Weight::from_ref_time(1_537_741 as u64).saturating_mul(r as u64)) + // Minimum execution time: 727 nanoseconds. + Weight::from_ref_time(1_056_556 as u64) + // Standard Error: 355 + .saturating_add(Weight::from_ref_time(830_505 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 69_221 nanoseconds. - Weight::from_ref_time(70_010_862 as u64) - // Standard Error: 1_845 - .saturating_add(Weight::from_ref_time(933_738 as u64).saturating_mul(r as u64)) + // Minimum execution time: 753 nanoseconds. + Weight::from_ref_time(1_004_624 as u64) + // Standard Error: 259 + .saturating_add(Weight::from_ref_time(693_886 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 69_081 nanoseconds. - Weight::from_ref_time(71_015_495 as u64) - // Standard Error: 27_078 - .saturating_add(Weight::from_ref_time(183_899_704 as u64).saturating_mul(r as u64)) + // Minimum execution time: 649 nanoseconds. + Weight::from_ref_time(742_979 as u64) + // Standard Error: 5_852 + .saturating_add(Weight::from_ref_time(184_932_720 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 70_589 nanoseconds. - Weight::from_ref_time(70_175_537 as u64) - // Standard Error: 1_355 - .saturating_add(Weight::from_ref_time(1_323_745 as u64).saturating_mul(r as u64)) + // Minimum execution time: 615 nanoseconds. + Weight::from_ref_time(919_735 as u64) + // Standard Error: 443 + .saturating_add(Weight::from_ref_time(509_234 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 69_083 nanoseconds. - Weight::from_ref_time(69_832_339 as u64) - // Standard Error: 818 - .saturating_add(Weight::from_ref_time(1_334_198 as u64).saturating_mul(r as u64)) + // Minimum execution time: 623 nanoseconds. + Weight::from_ref_time(883_408 as u64) + // Standard Error: 437 + .saturating_add(Weight::from_ref_time(517_270 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 69_084 nanoseconds. - Weight::from_ref_time(69_802_701 as u64) - // Standard Error: 744 - .saturating_add(Weight::from_ref_time(1_334_601 as u64).saturating_mul(r as u64)) + // Minimum execution time: 613 nanoseconds. + Weight::from_ref_time(819_503 as u64) + // Standard Error: 704 + .saturating_add(Weight::from_ref_time(518_031 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 69_052 nanoseconds. - Weight::from_ref_time(69_717_748 as u64) - // Standard Error: 571 - .saturating_add(Weight::from_ref_time(1_346_564 as u64).saturating_mul(r as u64)) + // Minimum execution time: 647 nanoseconds. + Weight::from_ref_time(922_130 as u64) + // Standard Error: 384 + .saturating_add(Weight::from_ref_time(525_187 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 69_016 nanoseconds. - Weight::from_ref_time(69_793_413 as u64) - // Standard Error: 769 - .saturating_add(Weight::from_ref_time(1_317_502 as u64).saturating_mul(r as u64)) + // Minimum execution time: 592 nanoseconds. + Weight::from_ref_time(930_340 as u64) + // Standard Error: 277 + .saturating_add(Weight::from_ref_time(505_104 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 69_043 nanoseconds. - Weight::from_ref_time(69_963_419 as u64) - // Standard Error: 1_117 - .saturating_add(Weight::from_ref_time(1_313_727 as u64).saturating_mul(r as u64)) + // Minimum execution time: 661 nanoseconds. + Weight::from_ref_time(942_938 as u64) + // Standard Error: 268 + .saturating_add(Weight::from_ref_time(504_997 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 69_032 nanoseconds. - Weight::from_ref_time(69_727_577 as u64) - // Standard Error: 662 - .saturating_add(Weight::from_ref_time(1_331_088 as u64).saturating_mul(r as u64)) + // Minimum execution time: 613 nanoseconds. + Weight::from_ref_time(864_875 as u64) + // Standard Error: 720 + .saturating_add(Weight::from_ref_time(508_015 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 69_097 nanoseconds. - Weight::from_ref_time(69_767_650 as u64) - // Standard Error: 2_056 - .saturating_add(Weight::from_ref_time(1_875_021 as u64).saturating_mul(r as u64)) + // Minimum execution time: 609 nanoseconds. + Weight::from_ref_time(964_975 as u64) + // Standard Error: 508 + .saturating_add(Weight::from_ref_time(732_494 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 69_153 nanoseconds. - Weight::from_ref_time(69_906_946 as u64) - // Standard Error: 1_060 - .saturating_add(Weight::from_ref_time(1_867_154 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(991_551 as u64) + // Standard Error: 1_126 + .saturating_add(Weight::from_ref_time(731_593 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 70_380 nanoseconds. - Weight::from_ref_time(69_867_328 as u64) - // Standard Error: 778 - .saturating_add(Weight::from_ref_time(1_869_718 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(938_821 as u64) + // Standard Error: 535 + .saturating_add(Weight::from_ref_time(741_527 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 69_259 nanoseconds. - Weight::from_ref_time(69_695_407 as u64) - // Standard Error: 746 - .saturating_add(Weight::from_ref_time(1_874_772 as u64).saturating_mul(r as u64)) + // Minimum execution time: 634 nanoseconds. + Weight::from_ref_time(969_389 as u64) + // Standard Error: 421 + .saturating_add(Weight::from_ref_time(743_647 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 68_986 nanoseconds. - Weight::from_ref_time(70_027_081 as u64) - // Standard Error: 1_401 - .saturating_add(Weight::from_ref_time(1_862_971 as u64).saturating_mul(r as u64)) + // Minimum execution time: 620 nanoseconds. + Weight::from_ref_time(997_361 as u64) + // Standard Error: 540 + .saturating_add(Weight::from_ref_time(748_108 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 68_953 nanoseconds. - Weight::from_ref_time(69_798_073 as u64) - // Standard Error: 1_000 - .saturating_add(Weight::from_ref_time(1_871_888 as u64).saturating_mul(r as u64)) + // Minimum execution time: 586 nanoseconds. + Weight::from_ref_time(966_929 as u64) + // Standard Error: 524 + .saturating_add(Weight::from_ref_time(760_077 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 68_909 nanoseconds. - Weight::from_ref_time(69_845_981 as u64) - // Standard Error: 775 - .saturating_add(Weight::from_ref_time(1_868_722 as u64).saturating_mul(r as u64)) + // Minimum execution time: 623 nanoseconds. + Weight::from_ref_time(974_811 as u64) + // Standard Error: 528 + .saturating_add(Weight::from_ref_time(745_124 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 68_986 nanoseconds. - Weight::from_ref_time(69_683_189 as u64) - // Standard Error: 503 - .saturating_add(Weight::from_ref_time(1_884_715 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(990_326 as u64) + // Standard Error: 535 + .saturating_add(Weight::from_ref_time(808_599 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 69_230 nanoseconds. - Weight::from_ref_time(69_765_336 as u64) - // Standard Error: 2_060 - .saturating_add(Weight::from_ref_time(1_871_848 as u64).saturating_mul(r as u64)) + // Minimum execution time: 600 nanoseconds. + Weight::from_ref_time(969_957 as u64) + // Standard Error: 604 + .saturating_add(Weight::from_ref_time(744_174 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 68_953 nanoseconds. - Weight::from_ref_time(69_828_265 as u64) - // Standard Error: 951 - .saturating_add(Weight::from_ref_time(1_868_596 as u64).saturating_mul(r as u64)) + // Minimum execution time: 632 nanoseconds. + Weight::from_ref_time(976_250 as u64) + // Standard Error: 938 + .saturating_add(Weight::from_ref_time(798_224 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 69_078 nanoseconds. - Weight::from_ref_time(69_832_768 as u64) - // Standard Error: 894 - .saturating_add(Weight::from_ref_time(1_845_786 as u64).saturating_mul(r as u64)) + // Minimum execution time: 627 nanoseconds. + Weight::from_ref_time(939_131 as u64) + // Standard Error: 457 + .saturating_add(Weight::from_ref_time(718_514 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 68_939 nanoseconds. - Weight::from_ref_time(69_676_256 as u64) - // Standard Error: 374 - .saturating_add(Weight::from_ref_time(1_851_026 as u64).saturating_mul(r as u64)) + // Minimum execution time: 621 nanoseconds. + Weight::from_ref_time(905_432 as u64) + // Standard Error: 637 + .saturating_add(Weight::from_ref_time(716_365 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 69_096 nanoseconds. - Weight::from_ref_time(69_914_159 as u64) - // Standard Error: 1_265 - .saturating_add(Weight::from_ref_time(1_844_489 as u64).saturating_mul(r as u64)) + // Minimum execution time: 610 nanoseconds. + Weight::from_ref_time(926_074 as u64) + // Standard Error: 457 + .saturating_add(Weight::from_ref_time(716_003 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 68_939 nanoseconds. - Weight::from_ref_time(69_641_768 as u64) - // Standard Error: 347 - .saturating_add(Weight::from_ref_time(2_488_628 as u64).saturating_mul(r as u64)) + // Minimum execution time: 595 nanoseconds. + Weight::from_ref_time(1_023_054 as u64) + // Standard Error: 2_584 + .saturating_add(Weight::from_ref_time(1_349_736 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 69_114 nanoseconds. - Weight::from_ref_time(69_844_395 as u64) - // Standard Error: 1_489 - .saturating_add(Weight::from_ref_time(2_456_310 as u64).saturating_mul(r as u64)) + // Minimum execution time: 608 nanoseconds. + Weight::from_ref_time(966_937 as u64) + // Standard Error: 786 + .saturating_add(Weight::from_ref_time(1_284_291 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 69_082 nanoseconds. - Weight::from_ref_time(69_993_662 as u64) - // Standard Error: 1_218 - .saturating_add(Weight::from_ref_time(2_524_010 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(972_082 as u64) + // Standard Error: 1_441 + .saturating_add(Weight::from_ref_time(1_403_148 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 69_036 nanoseconds. - Weight::from_ref_time(70_095_304 as u64) - // Standard Error: 1_473 - .saturating_add(Weight::from_ref_time(2_429_659 as u64).saturating_mul(r as u64)) + // Minimum execution time: 644 nanoseconds. + Weight::from_ref_time(991_706 as u64) + // Standard Error: 1_103 + .saturating_add(Weight::from_ref_time(1_284_545 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 69_229 nanoseconds. - Weight::from_ref_time(69_759_818 as u64) - // Standard Error: 573 - .saturating_add(Weight::from_ref_time(1_879_670 as u64).saturating_mul(r as u64)) + // Minimum execution time: 630 nanoseconds. + Weight::from_ref_time(941_587 as u64) + // Standard Error: 506 + .saturating_add(Weight::from_ref_time(719_943 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 69_151 nanoseconds. - Weight::from_ref_time(69_865_948 as u64) - // Standard Error: 721 - .saturating_add(Weight::from_ref_time(1_846_734 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(939_991 as u64) + // Standard Error: 520 + .saturating_add(Weight::from_ref_time(719_994 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 69_120 nanoseconds. - Weight::from_ref_time(70_135_849 as u64) - // Standard Error: 3_443 - .saturating_add(Weight::from_ref_time(1_841_784 as u64).saturating_mul(r as u64)) + // Minimum execution time: 609 nanoseconds. + Weight::from_ref_time(970_308 as u64) + // Standard Error: 552 + .saturating_add(Weight::from_ref_time(719_566 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 69_077 nanoseconds. - Weight::from_ref_time(69_929_746 as u64) - // Standard Error: 821 - .saturating_add(Weight::from_ref_time(1_866_348 as u64).saturating_mul(r as u64)) + // Minimum execution time: 613 nanoseconds. + Weight::from_ref_time(920_835 as u64) + // Standard Error: 623 + .saturating_add(Weight::from_ref_time(737_690 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 69_226 nanoseconds. - Weight::from_ref_time(69_725_630 as u64) - // Standard Error: 891 - .saturating_add(Weight::from_ref_time(1_873_637 as u64).saturating_mul(r as u64)) + // Minimum execution time: 626 nanoseconds. + Weight::from_ref_time(919_030 as u64) + // Standard Error: 486 + .saturating_add(Weight::from_ref_time(737_096 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 70_591 nanoseconds. - Weight::from_ref_time(69_939_773 as u64) - // Standard Error: 960 - .saturating_add(Weight::from_ref_time(1_867_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 634 nanoseconds. + Weight::from_ref_time(964_779 as u64) + // Standard Error: 496 + .saturating_add(Weight::from_ref_time(736_322 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 69_187 nanoseconds. - Weight::from_ref_time(69_845_516 as u64) - // Standard Error: 781 - .saturating_add(Weight::from_ref_time(1_869_613 as u64).saturating_mul(r as u64)) + // Minimum execution time: 631 nanoseconds. + Weight::from_ref_time(918_768 as u64) + // Standard Error: 952 + .saturating_add(Weight::from_ref_time(740_280 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 69_065 nanoseconds. - Weight::from_ref_time(69_950_430 as u64) - // Standard Error: 986 - .saturating_add(Weight::from_ref_time(1_867_001 as u64).saturating_mul(r as u64)) + // Minimum execution time: 639 nanoseconds. + Weight::from_ref_time(955_994 as u64) + // Standard Error: 523 + .saturating_add(Weight::from_ref_time(738_232 as u64).saturating_mul(r as u64)) } -} \ No newline at end of file +} From f3ce2fd2c615094ce6bf6ad921aa0ed17268e97c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 17 Nov 2022 14:09:51 +0100 Subject: [PATCH 13/27] Fixup naming inconsistencies introduced by reentrancy PR --- ..._count_call.wat => reentrance_count_call.wat} | 14 +++++++------- ...l.wat => reentrance_count_delegated_call.wat} | 6 +++--- frame/contracts/src/benchmarking/mod.rs | 6 +++--- frame/contracts/src/exec.rs | 4 ++-- frame/contracts/src/schedule.rs | 6 +++--- frame/contracts/src/tests.rs | 16 ++++++++-------- frame/contracts/src/wasm/mod.rs | 8 ++++---- frame/contracts/src/wasm/runtime.rs | 8 ++++---- frame/contracts/src/weights.rs | 12 ++++++------ 9 files changed, 40 insertions(+), 40 deletions(-) rename frame/contracts/fixtures/{reentrant_count_call.wat => reentrance_count_call.wat} (80%) rename frame/contracts/fixtures/{reentrant_count_delegated_call.wat => reentrance_count_delegated_call.wat} (88%) diff --git a/frame/contracts/fixtures/reentrant_count_call.wat b/frame/contracts/fixtures/reentrance_count_call.wat similarity index 80% rename from frame/contracts/fixtures/reentrant_count_call.wat rename to frame/contracts/fixtures/reentrance_count_call.wat index 5b4b7220cf478..0577314066f74 100644 --- a/frame/contracts/fixtures/reentrant_count_call.wat +++ b/frame/contracts/fixtures/reentrance_count_call.wat @@ -1,10 +1,10 @@ -;; This fixture recursively tests if reentrant_count returns correct reentrant count value when +;; This fixture recursively tests if reentrance_count returns correct reentrant count value when ;; using seal_call to make caller contract call to itself (module (import "seal0" "seal_input" (func $seal_input (param i32 i32))) (import "seal0" "seal_address" (func $seal_address (param i32 i32))) (import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32))) - (import "__unstable__" "reentrant_count" (func $reentrant_count (result i32))) + (import "__unstable__" "reentrance_count" (func $reentrance_count (result i32))) (import "env" "memory" (memory 1 1)) ;; [0, 32) reserved for $seal_address output @@ -26,7 +26,7 @@ ) ) (func (export "call") - (local $expected_reentrant_count i32) + (local $expected_reentrance_count i32) (local $seal_call_exit_code i32) ;; reading current contract address @@ -36,19 +36,19 @@ (call $seal_input (i32.const 32) (i32.const 36)) ;; reading manually passed reentrant count - (set_local $expected_reentrant_count (i32.load (i32.const 32))) + (set_local $expected_reentrance_count (i32.load (i32.const 32))) ;; reentrance count is calculated correctly (call $assert - (i32.eq (call $reentrant_count) (get_local $expected_reentrant_count)) + (i32.eq (call $reentrance_count) (get_local $expected_reentrance_count)) ) ;; re-enter 5 times in a row and assert that the reentrant counter works as expected - (i32.eq (call $reentrant_count) (i32.const 5)) + (i32.eq (call $reentrance_count) (i32.const 5)) (if (then) ;; recursion exit case (else - ;; incrementing $expected_reentrant_count passed to the contract + ;; incrementing $expected_reentrance_count passed to the contract (i32.store (i32.const 32) (i32.add (i32.load (i32.const 32)) (i32.const 1))) ;; Call to itself diff --git a/frame/contracts/fixtures/reentrant_count_delegated_call.wat b/frame/contracts/fixtures/reentrance_count_delegated_call.wat similarity index 88% rename from frame/contracts/fixtures/reentrant_count_delegated_call.wat rename to frame/contracts/fixtures/reentrance_count_delegated_call.wat index de8f7c1a7a954..144df25d76835 100644 --- a/frame/contracts/fixtures/reentrant_count_delegated_call.wat +++ b/frame/contracts/fixtures/reentrance_count_delegated_call.wat @@ -1,10 +1,10 @@ -;; This fixture recursively tests if reentrant_count returns correct reentrant count value when +;; This fixture recursively tests if reentrance_count returns correct reentrant count value when ;; using seal_delegate_call to make caller contract delegate call to itself (module (import "seal0" "seal_input" (func $seal_input (param i32 i32))) (import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32))) (import "seal0" "seal_delegate_call" (func $seal_delegate_call (param i32 i32 i32 i32 i32 i32) (result i32))) - (import "__unstable__" "reentrant_count" (func $reentrant_count (result i32))) + (import "__unstable__" "reentrance_count" (func $reentrance_count (result i32))) (import "env" "memory" (memory 1 1)) ;; [0, 32) buffer where code hash is copied @@ -37,7 +37,7 @@ ;; reentrance count stays 0 (call $assert - (i32.eq (call $reentrant_count) (i32.const 0)) + (i32.eq (call $reentrance_count) (i32.const 0)) ) (i32.eq (get_local $callstack_height) (i32.const 5)) diff --git a/frame/contracts/src/benchmarking/mod.rs b/frame/contracts/src/benchmarking/mod.rs index 1840bf9abe1be..bce2b4ae5e78c 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -2045,7 +2045,7 @@ benchmarks! { let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) - seal_set_code_hash { + seal_reentrance_count { let r in 0 .. API_BENCHMARK_BATCHES; let code_hashes = (0..r * API_BENCHMARK_BATCH_SIZE) .map(|i| { @@ -2085,13 +2085,13 @@ benchmarks! { let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) - reentrant_count { + seal_account_reentrance_count { let r in 0 .. API_BENCHMARK_BATCHES; let code = WasmModule::::from(ModuleDefinition { memory: Some(ImportedMemory::max::()), imported_functions: vec![ImportedFunction { module: "__unstable__", - name: "reentrant_count", + name: "reentrance_count", params: vec![], return_type: Some(ValueType::I32), }], diff --git a/frame/contracts/src/exec.rs b/frame/contracts/src/exec.rs index 76b200001af78..2884779d8fda7 100644 --- a/frame/contracts/src/exec.rs +++ b/frame/contracts/src/exec.rs @@ -299,7 +299,7 @@ pub trait Ext: sealing::Sealed { /// Returns the number of times the currently executing contract exists on the call stack in /// addition to the calling instance. A value of 0 means no reentrancy. - fn reentrant_count(&self) -> u32; + fn reentrance_count(&self) -> u32; /// Returns the number of times the specified contract exists on the call stack. Delegated calls /// are not calculated as separate entrance. @@ -1384,7 +1384,7 @@ where Ok(()) } - fn reentrant_count(&self) -> u32 { + fn reentrance_count(&self) -> u32 { let id: &AccountIdOf = &self.top_frame().account_id; self.account_reentrance_count(id).saturating_sub(1) } diff --git a/frame/contracts/src/schedule.rs b/frame/contracts/src/schedule.rs index f4232731414e2..79f9f49e58190 100644 --- a/frame/contracts/src/schedule.rs +++ b/frame/contracts/src/schedule.rs @@ -423,8 +423,8 @@ pub struct HostFnWeights { /// Weight of calling `seal_ecdsa_to_eth_address`. pub ecdsa_to_eth_address: u64, - /// Weight of calling `seal_reentrant_count`. - pub reentrant_count: u64, + /// Weight of calling `seal_reentrance_count`. + pub reentrance_count: u64, /// Weight of calling `seal_account_reentrance_count`. pub account_reentrance_count: u64, @@ -665,7 +665,7 @@ impl Default for HostFnWeights { hash_blake2_128_per_byte: cost_byte_batched!(seal_hash_blake2_128_per_kb), ecdsa_recover: cost_batched!(seal_ecdsa_recover), ecdsa_to_eth_address: cost_batched!(seal_ecdsa_to_eth_address), - reentrant_count: cost_batched!(seal_reentrant_count), + reentrance_count: cost_batched!(seal_reentrance_count), account_reentrance_count: cost_batched!(seal_account_reentrance_count), _phantom: PhantomData, } diff --git a/frame/contracts/src/tests.rs b/frame/contracts/src/tests.rs index f89acb67cbcb4..e7b27ed38e271 100644 --- a/frame/contracts/src/tests.rs +++ b/frame/contracts/src/tests.rs @@ -4412,8 +4412,8 @@ fn delegate_call_indeterministic_code() { #[test] #[cfg(feature = "unstable-interface")] -fn reentrant_count_works_with_call() { - let (wasm, code_hash) = compile_module::("reentrant_count_call").unwrap(); +fn reentrance_count_works_with_call() { + let (wasm, code_hash) = compile_module::("reentrance_count_call").unwrap(); let contract_addr = Contracts::contract_address(&ALICE, &code_hash, &[]); ExtBuilder::default().existential_deposit(100).build().execute_with(|| { @@ -4449,8 +4449,8 @@ fn reentrant_count_works_with_call() { #[test] #[cfg(feature = "unstable-interface")] -fn reentrant_count_works_with_delegated_call() { - let (wasm, code_hash) = compile_module::("reentrant_count_delegated_call").unwrap(); +fn reentrance_count_works_with_delegated_call() { + let (wasm, code_hash) = compile_module::("reentrance_count_delegated_call").unwrap(); let contract_addr = Contracts::contract_address(&ALICE, &code_hash, &[]); ExtBuilder::default().existential_deposit(100).build().execute_with(|| { @@ -4488,8 +4488,8 @@ fn reentrant_count_works_with_delegated_call() { #[cfg(feature = "unstable-interface")] fn account_reentrance_count_works() { let (wasm, code_hash) = compile_module::("account_reentrance_count_call").unwrap(); - let (wasm_reentrant_count, code_hash_reentrant_count) = - compile_module::("reentrant_count_call").unwrap(); + let (wasm_reentrance_count, code_hash_reentrance_count) = + compile_module::("reentrance_count_call").unwrap(); ExtBuilder::default().existential_deposit(100).build().execute_with(|| { let _ = Balances::deposit_creating(&ALICE, 1_000_000); @@ -4509,14 +4509,14 @@ fn account_reentrance_count_works() { 300_000, GAS_LIMIT, None, - wasm_reentrant_count, + wasm_reentrance_count, vec![], vec![] )); let contract_addr = Contracts::contract_address(&ALICE, &code_hash, &[]); let another_contract_addr = - Contracts::contract_address(&ALICE, &code_hash_reentrant_count, &[]); + Contracts::contract_address(&ALICE, &code_hash_reentrance_count, &[]); let result1 = Contracts::bare_call( ALICE, diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 336d23c1a2059..844862bf22b1a 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -614,7 +614,7 @@ mod tests { fn ecdsa_to_eth_address(&self, _pk: &[u8; 33]) -> Result<[u8; 20], ()> { Ok([2u8; 20]) } - fn reentrant_count(&self) -> u32 { + fn reentrance_count(&self) -> u32 { 12 } fn account_reentrance_count(&self, _account_id: &AccountIdOf) -> u32 { @@ -2890,10 +2890,10 @@ mod tests { #[test] #[cfg(feature = "unstable-interface")] - fn reentrant_count_works() { + fn reentrance_count_works() { const CODE: &str = r#" (module - (import "__unstable__" "reentrant_count" (func $reentrant_count (result i32))) + (import "__unstable__" "reentrance_count" (func $reentrance_count (result i32))) (import "env" "memory" (memory 1 1)) (func $assert (param i32) (block $ok @@ -2906,7 +2906,7 @@ mod tests { (func (export "call") (local $return_val i32) (set_local $return_val - (call $reentrant_count) + (call $reentrance_count) ) (call $assert (i32.eq (get_local $return_val) (i32.const 12)) diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 2615ee83b016b..8060e281cd948 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -261,7 +261,7 @@ pub enum RuntimeCosts { SetCodeHash, /// Weight of calling `ecdsa_to_eth_address` EcdsaToEthAddress, - /// Weight of calling `seal_reentrant_count` + /// Weight of calling `seal_reentrance_count` #[cfg(feature = "unstable-interface")] ReentrantCount, /// Weight of calling `seal_account_reentrance_count` @@ -347,7 +347,7 @@ impl RuntimeCosts { SetCodeHash => s.set_code_hash, EcdsaToEthAddress => s.ecdsa_to_eth_address, #[cfg(feature = "unstable-interface")] - ReentrantCount => s.reentrant_count, + ReentrantCount => s.reentrance_count, #[cfg(feature = "unstable-interface")] AccountEntranceCount => s.account_reentrance_count, }; @@ -2598,9 +2598,9 @@ pub mod env { /// /// Returns 0 when there is no reentrancy. #[unstable] - fn reentrant_count(ctx: _, memory: _) -> Result { + fn reentrance_count(ctx: _, memory: _) -> Result { ctx.charge_gas(RuntimeCosts::ReentrantCount)?; - Ok(ctx.ext.reentrant_count()) + Ok(ctx.ext.reentrance_count()) } /// Returns the number of times specified contract exists on the call stack. Delegated calls are diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index bee0e6be683e2..b54ef2315dc9a 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -110,8 +110,8 @@ pub trait WeightInfo { 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 reentrant_count(r: u32, ) -> Weight; - fn account_reentrance_count(r: u32, ) -> Weight; + fn seal_reentrance_count(r: u32, ) -> Weight; + fn seal_account_reentrance_count(r: u32, ) -> Weight; fn instr_i64const(r: u32, ) -> Weight; fn instr_i64load(r: u32, ) -> Weight; fn instr_i64store(r: u32, ) -> Weight; @@ -1031,7 +1031,7 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn reentrant_count(r: u32, ) -> Weight { + fn seal_reentrance_count(r: u32, ) -> Weight { // Minimum execution time: 290_954 nanoseconds. Weight::from_ref_time(295_190_436 as u64) // Standard Error: 40_295 @@ -1045,7 +1045,7 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn account_reentrance_count(r: u32, ) -> Weight { + fn seal_account_reentrance_count(r: u32, ) -> Weight { // Minimum execution time: 292_817 nanoseconds. Weight::from_ref_time(331_195_835 as u64) // Standard Error: 126_642 @@ -2277,7 +2277,7 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn reentrant_count(r: u32, ) -> Weight { + fn seal_reentrance_count(r: u32, ) -> Weight { // Minimum execution time: 290_954 nanoseconds. Weight::from_ref_time(295_190_436 as u64) // Standard Error: 40_295 @@ -2291,7 +2291,7 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn account_reentrance_count(r: u32, ) -> Weight { + fn seal_account_reentrance_count(r: u32, ) -> Weight { // Minimum execution time: 292_817 nanoseconds. Weight::from_ref_time(331_195_835 as u64) // Standard Error: 126_642 From 589a1005c210f4d289f828568e979103aa2ee9ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 17 Nov 2022 14:23:40 +0100 Subject: [PATCH 14/27] Fix `scan_imports` docs --- frame/contracts/src/wasm/prepare.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index c61e56914e1db..95231741ac668 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -292,10 +292,9 @@ impl<'a, T: Config> ContractModule<'a, T> { /// Scan an import section if any. /// - /// This accomplishes two tasks: + /// This makes sure that the import section looks as we expect it from a contract + /// and enforces and returns the memory type declared by the contract if any. /// - /// - checks any imported function against defined host functions set, incl. their signatures. - /// - if there is a memory import, returns it's descriptor /// `import_fn_banlist`: list of function names that are disallowed to be imported fn scan_imports( &self, From 8505a544d92e3b1d19d1f7a82052529426c75899 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 17 Nov 2022 14:28:04 +0100 Subject: [PATCH 15/27] Apply suggestions from code review Co-authored-by: Sasha Gryaznov --- frame/contracts/proc-macro/src/lib.rs | 8 ++++---- frame/contracts/src/wasm/prepare.rs | 4 ++-- frame/contracts/src/wasm/runtime.rs | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index f597cdbddf5c9..fffe1e5348d7a 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -214,7 +214,7 @@ impl HostFn { }?; // process arguments: The first and second arg are treated differently (ctx, memory) - // hhey must exist and be `ctx: _` and `memory: _`. + // they must exist and be `ctx: _` and `memory: _`. let msg = "Every function must start with two inferred parameters: ctx: _ and memory: _"; let special_args = item .sig @@ -367,7 +367,6 @@ fn is_valid_special_arg(idx: usize, arg: &FnArg) -> bool { /// Expands environment definiton. /// Should generate source code for: -/// - wasm import satisfy checks (see `expand_can_satisfy()`); /// - implementations of the host functions to be added to the wasm runtime environment (see /// `expand_impls()`). fn expand_env(def: &mut EnvDef) -> TokenStream2 { @@ -379,8 +378,9 @@ fn expand_env(def: &mut EnvDef) -> TokenStream2 { } } -/// Generates implementation for every host function, to register it in the contract execution -/// environment. +/// Generates for every host function: +/// - 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: &mut EnvDef) -> TokenStream2 { let impls = expand_functions(def, true, quote! { crate::wasm::Runtime }); let dummy_impls = expand_functions(def, false, quote! { () }); diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 95231741ac668..40c6e5df36ed1 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -41,7 +41,7 @@ pub const IMPORT_MODULE_MEMORY: &str = "env"; /// Determines whether a module should be instantiated during preparation. pub enum TryInstantiate { - /// Do the innstantiation to make sure that the module is valid. + /// Do the instantiation to make sure that the module is valid. /// /// This should be used if a module is only uploaded but not executed. We need /// to make sure that it can be actually instantiated. @@ -455,7 +455,7 @@ where // reduces the amount of memory that needs to be zeroed. let stack_limits = StackLimits::new(1, 1, 0).expect("initial <= max; qed"); PrefabWasmModule::::instantiate::( - original_code, + code, (), (initial, maximum), stack_limits, diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 8060e281cd948..7d5c25d60e6a4 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -38,9 +38,9 @@ use wasmi::{core::HostError, errors::LinkerError, Linker, Memory, Store}; /// The maximum nesting depth a contract can use when encoding types. const MAX_DECODE_NESTING: u32 = 256; -/// Trait implemented by the [`define_env`] macro for the emitted `Env` struct. +/// Trait implemented by the [`define_env`](pallet_contracts_proc_macro::define_env) macro for the emitted `Env` struct. pub trait Environment { - /// Adds all declared functions to the supplied [`Linker`] and [`Store`]. + /// Adds all declared functions to the supplied [`Linker`](wasmi::Linker) and [`Store`](wasmi::Store). fn define( store: &mut Store, linker: &mut Linker, From 92446423903dbee44b8048f0e9cf6af1229593aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 17 Nov 2022 14:32:22 +0100 Subject: [PATCH 16/27] Fixup suggestions --- frame/contracts/proc-macro/src/lib.rs | 2 +- frame/contracts/src/wasm/prepare.rs | 15 +++++---------- frame/contracts/src/wasm/runtime.rs | 6 ++++-- 3 files changed, 10 insertions(+), 13 deletions(-) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index fffe1e5348d7a..c94b0d94224ed 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -380,7 +380,7 @@ fn expand_env(def: &mut EnvDef) -> TokenStream2 { /// Generates for every host function: /// - real implementation, to register it in the contract execution environment; -/// - dummy implementation, to be used as mocks for contract validation step. +/// - dummy implementation, to be used as mocks for contract validation step. fn expand_impls(def: &mut EnvDef) -> TokenStream2 { let impls = expand_functions(def, true, quote! { crate::wasm::Runtime }); let dummy_impls = expand_functions(def, false, quote! { () }); diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 40c6e5df36ed1..b1d512828c0ee 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -454,16 +454,11 @@ where // We don't actually ever run any code so we can get away with a minimal stack which // reduces the amount of memory that needs to be zeroed. let stack_limits = StackLimits::new(1, 1, 0).expect("initial <= max; qed"); - PrefabWasmModule::::instantiate::( - code, - (), - (initial, maximum), - stack_limits, - ) - .map_err(|err| { - log::debug!(target: "runtime::contracts", "{}", err); - (Error::::CodeRejected.into(), "new code rejected after instrumentation") - })?; + PrefabWasmModule::::instantiate::(&code, (), (initial, maximum), stack_limits) + .map_err(|err| { + log::debug!(target: "runtime::contracts", "{}", err); + (Error::::CodeRejected.into(), "new code rejected after instrumentation") + })?; } Ok((code, (initial, maximum))) diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 7d5c25d60e6a4..4f3e0976651fb 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -38,9 +38,11 @@ use wasmi::{core::HostError, errors::LinkerError, Linker, Memory, Store}; /// The maximum nesting depth a contract can use when encoding types. const MAX_DECODE_NESTING: u32 = 256; -/// Trait implemented by the [`define_env`](pallet_contracts_proc_macro::define_env) macro for the emitted `Env` struct. +/// Trait implemented by the [`define_env`](pallet_contracts_proc_macro::define_env) macro for the +/// emitted `Env` struct. pub trait Environment { - /// Adds all declared functions to the supplied [`Linker`](wasmi::Linker) and [`Store`](wasmi::Store). + /// Adds all declared functions to the supplied [`Linker`](wasmi::Linker) and + /// [`Store`](wasmi::Store). fn define( store: &mut Store, linker: &mut Linker, From af4e34f3bda271c6decd402dd50c5899dd6d9531 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 17 Nov 2022 14:32:44 +0100 Subject: [PATCH 17/27] Remove unnecessary &mut --- frame/contracts/src/wasm/runtime.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 4f3e0976651fb..37ff68d7107fa 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -684,7 +684,7 @@ where /// /// - designated area is not within the bounds of the sandbox memory. fn write_sandbox_memory( - &mut self, + &self, memory: &mut [u8], ptr: u32, buf: &[u8], @@ -709,7 +709,7 @@ where /// /// The `input` and `output` buffers may overlap. fn compute_hash_on_intermediate_buffer( - &mut self, + &self, memory: &mut [u8], hash_fn: F, input_ptr: u32, From 94b30c2812aad162e36069d185da9139ddb54736 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 17 Nov 2022 14:57:40 +0100 Subject: [PATCH 18/27] Fix test --- frame/contracts/src/wasm/prepare.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index b1d512828c0ee..92aa7e1fc7f2c 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -613,7 +613,7 @@ mod tests { } // gas is an implementation defined function and a contract can't import it. - fn gas(_ctx: _, _memory: _, _amount: u32) -> Result<(), TrapReason> { + fn gas(_ctx: _, _memory: _, _amount: u64) -> Result<(), TrapReason> { Ok(()) } From ec7522e65e3227ebdf0149a3c2fc8ffc93a5f289 Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Thu, 17 Nov 2022 16:16:46 +0000 Subject: [PATCH 19/27] ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts --- frame/contracts/src/weights.rs | 1852 ++++++++++++++++---------------- 1 file changed, 924 insertions(+), 928 deletions(-) diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index b54ef2315dc9a..5c097f616885f 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -18,7 +18,7 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-11-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-11-17, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 @@ -109,9 +109,9 @@ pub trait WeightInfo { fn seal_hash_blake2_128_per_kb(n: 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 seal_reentrance_count(r: u32, ) -> Weight; fn seal_account_reentrance_count(r: u32, ) -> Weight; + fn account_reentrance_count(r: u32, ) -> Weight; fn instr_i64const(r: u32, ) -> Weight; fn instr_i64load(r: u32, ) -> Weight; fn instr_i64store(r: u32, ) -> Weight; @@ -170,17 +170,17 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 3_092 nanoseconds. - Weight::from_ref_time(3_273_000 as u64) + // Minimum execution time: 3_254 nanoseconds. + Weight::from_ref_time(3_367_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 15_553 nanoseconds. - Weight::from_ref_time(17_898_219 as u64) - // Standard Error: 612 - .saturating_add(Weight::from_ref_time(959_535 as u64).saturating_mul(k as u64)) + // Minimum execution time: 16_206 nanoseconds. + Weight::from_ref_time(19_434_064 as u64) + // Standard Error: 715 + .saturating_add(Weight::from_ref_time(963_296 as u64).saturating_mul(k as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -188,10 +188,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 3_051 nanoseconds. - Weight::from_ref_time(16_045_885 as u64) - // Standard Error: 3_894 - .saturating_add(Weight::from_ref_time(1_251_095 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_130 nanoseconds. + Weight::from_ref_time(18_640_668 as u64) + // Standard Error: 4_357 + .saturating_add(Weight::from_ref_time(1_274_044 as u64).saturating_mul(q as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -199,10 +199,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 29_767 nanoseconds. - Weight::from_ref_time(24_442_384 as u64) - // Standard Error: 41 - .saturating_add(Weight::from_ref_time(47_060 as u64).saturating_mul(c as u64)) + // Minimum execution time: 29_419 nanoseconds. + Weight::from_ref_time(20_616_893 as u64) + // Standard Error: 44 + .saturating_add(Weight::from_ref_time(47_249 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -213,10 +213,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 307_279 nanoseconds. - Weight::from_ref_time(317_807_474 as u64) - // Standard Error: 17 - .saturating_add(Weight::from_ref_time(30_874 as u64).saturating_mul(c as u64)) + // Minimum execution time: 311_735 nanoseconds. + Weight::from_ref_time(324_179_000 as u64) + // Standard Error: 23 + .saturating_add(Weight::from_ref_time(31_787 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -231,12 +231,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_173_376 nanoseconds. - Weight::from_ref_time(333_991_198 as u64) - // Standard Error: 47 - .saturating_add(Weight::from_ref_time(90_283 as u64).saturating_mul(c as u64)) - // Standard Error: 2 - .saturating_add(Weight::from_ref_time(1_782 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_187_833 nanoseconds. + Weight::from_ref_time(419_021_666 as u64) + // Standard Error: 64 + .saturating_add(Weight::from_ref_time(91_150 as u64).saturating_mul(c as u64)) + // Standard Error: 3 + .saturating_add(Weight::from_ref_time(1_767 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } @@ -249,10 +249,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 187_549 nanoseconds. - Weight::from_ref_time(176_268_968 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_525 as u64).saturating_mul(s as u64)) + // Minimum execution time: 193_073 nanoseconds. + Weight::from_ref_time(177_294_408 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_563 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } @@ -262,8 +262,8 @@ impl WeightInfo for SubstrateWeight { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 156_476 nanoseconds. - Weight::from_ref_time(157_462_000 as u64) + // Minimum execution time: 160_898 nanoseconds. + Weight::from_ref_time(161_990_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -273,10 +273,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 295_320 nanoseconds. - Weight::from_ref_time(305_011_007 as u64) - // Standard Error: 53 - .saturating_add(Weight::from_ref_time(77_528 as u64).saturating_mul(c as u64)) + // Minimum execution time: 305_859 nanoseconds. + Weight::from_ref_time(309_986_743 as u64) + // Standard Error: 65 + .saturating_add(Weight::from_ref_time(91_731 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -285,8 +285,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 39_868 nanoseconds. - Weight::from_ref_time(40_885_000 as u64) + // Minimum execution time: 41_544 nanoseconds. + Weight::from_ref_time(41_956_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -294,8 +294,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 42_082 nanoseconds. - Weight::from_ref_time(42_487_000 as u64) + // Minimum execution time: 43_313 nanoseconds. + Weight::from_ref_time(43_987_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } @@ -306,10 +306,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 295_276 nanoseconds. - Weight::from_ref_time(300_528_395 as u64) - // Standard Error: 22_438 - .saturating_add(Weight::from_ref_time(16_661_252 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_251 nanoseconds. + Weight::from_ref_time(308_118_154 as u64) + // Standard Error: 13_919 + .saturating_add(Weight::from_ref_time(16_555_470 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -320,10 +320,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 296_022 nanoseconds. - Weight::from_ref_time(231_263_577 as u64) - // Standard Error: 430_945 - .saturating_add(Weight::from_ref_time(199_389_344 as u64).saturating_mul(r as u64)) + // Minimum execution time: 302_090 nanoseconds. + Weight::from_ref_time(237_951_992 as u64) + // Standard Error: 425_584 + .saturating_add(Weight::from_ref_time(213_514_628 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -335,10 +335,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 297_796 nanoseconds. - Weight::from_ref_time(243_158_249 as u64) - // Standard Error: 396_560 - .saturating_add(Weight::from_ref_time(242_784_462 as u64).saturating_mul(r as u64)) + // Minimum execution time: 303_203 nanoseconds. + Weight::from_ref_time(263_005_297 as u64) + // Standard Error: 376_919 + .saturating_add(Weight::from_ref_time(265_396_805 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -350,10 +350,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 297_206 nanoseconds. - Weight::from_ref_time(302_423_708 as u64) - // Standard Error: 18_660 - .saturating_add(Weight::from_ref_time(20_507_825 as u64).saturating_mul(r as u64)) + // Minimum execution time: 304_113 nanoseconds. + Weight::from_ref_time(311_754_829 as u64) + // Standard Error: 18_343 + .saturating_add(Weight::from_ref_time(19_940_285 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -364,10 +364,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 293_337 nanoseconds. - Weight::from_ref_time(298_462_585 as u64) - // Standard Error: 15_979 - .saturating_add(Weight::from_ref_time(11_165_786 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_259 nanoseconds. + Weight::from_ref_time(308_994_291 as u64) + // Standard Error: 14_116 + .saturating_add(Weight::from_ref_time(11_176_417 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -378,10 +378,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 294_982 nanoseconds. - Weight::from_ref_time(299_538_930 as u64) - // Standard Error: 18_777 - .saturating_add(Weight::from_ref_time(16_575_318 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_414 nanoseconds. + Weight::from_ref_time(310_130_007 as u64) + // Standard Error: 21_977 + .saturating_add(Weight::from_ref_time(16_288_617 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -392,10 +392,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 295_266 nanoseconds. - Weight::from_ref_time(301_023_294 as u64) - // Standard Error: 18_987 - .saturating_add(Weight::from_ref_time(16_152_668 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_342 nanoseconds. + Weight::from_ref_time(308_941_812 as u64) + // Standard Error: 15_417 + .saturating_add(Weight::from_ref_time(16_046_689 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -406,10 +406,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 293_847 nanoseconds. - Weight::from_ref_time(302_991_846 as u64) - // Standard Error: 36_830 - .saturating_add(Weight::from_ref_time(89_091_598 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_133 nanoseconds. + Weight::from_ref_time(311_277_478 as u64) + // Standard Error: 35_954 + .saturating_add(Weight::from_ref_time(97_275_936 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -420,10 +420,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 295_907 nanoseconds. - Weight::from_ref_time(300_322_285 as u64) - // Standard Error: 20_612 - .saturating_add(Weight::from_ref_time(16_199_834 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_980 nanoseconds. + Weight::from_ref_time(308_487_901 as u64) + // Standard Error: 15_791 + .saturating_add(Weight::from_ref_time(15_971_242 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -434,10 +434,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 295_042 nanoseconds. - Weight::from_ref_time(299_750_507 as u64) - // Standard Error: 19_981 - .saturating_add(Weight::from_ref_time(16_290_215 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_042 nanoseconds. + Weight::from_ref_time(308_378_169 as u64) + // Standard Error: 13_644 + .saturating_add(Weight::from_ref_time(15_940_362 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -448,10 +448,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 295_129 nanoseconds. - Weight::from_ref_time(301_389_224 as u64) - // Standard Error: 20_956 - .saturating_add(Weight::from_ref_time(15_947_448 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_913 nanoseconds. + Weight::from_ref_time(306_528_553 as u64) + // Standard Error: 18_702 + .saturating_add(Weight::from_ref_time(16_259_237 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -462,10 +462,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 295_128 nanoseconds. - Weight::from_ref_time(299_569_582 as u64) - // Standard Error: 18_853 - .saturating_add(Weight::from_ref_time(16_304_774 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_639 nanoseconds. + Weight::from_ref_time(310_298_448 as u64) + // Standard Error: 20_201 + .saturating_add(Weight::from_ref_time(15_923_667 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -477,10 +477,10 @@ impl WeightInfo for SubstrateWeight { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 295_229 nanoseconds. - Weight::from_ref_time(305_986_569 as u64) - // Standard Error: 33_339 - .saturating_add(Weight::from_ref_time(85_497_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_200 nanoseconds. + Weight::from_ref_time(312_744_329 as u64) + // Standard Error: 33_748 + .saturating_add(Weight::from_ref_time(88_361_056 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -491,10 +491,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 144_560 nanoseconds. - Weight::from_ref_time(147_780_996 as u64) - // Standard Error: 8_658 - .saturating_add(Weight::from_ref_time(8_185_717 as u64).saturating_mul(r as u64)) + // Minimum execution time: 148_130 nanoseconds. + Weight::from_ref_time(151_542_553 as u64) + // Standard Error: 9_571 + .saturating_add(Weight::from_ref_time(8_134_705 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -505,10 +505,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 291_869 nanoseconds. - Weight::from_ref_time(300_501_085 as u64) - // Standard Error: 17_955 - .saturating_add(Weight::from_ref_time(13_899_691 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_987 nanoseconds. + Weight::from_ref_time(307_696_695 as u64) + // Standard Error: 15_723 + .saturating_add(Weight::from_ref_time(14_189_895 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -519,10 +519,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 312_247 nanoseconds. - Weight::from_ref_time(327_623_543 as u64) - // Standard Error: 1_162 - .saturating_add(Weight::from_ref_time(9_752_573 as u64).saturating_mul(n as u64)) + // Minimum execution time: 318_276 nanoseconds. + Weight::from_ref_time(335_793_925 as u64) + // Standard Error: 1_344 + .saturating_add(Weight::from_ref_time(9_778_604 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -533,10 +533,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 290_105 nanoseconds. - Weight::from_ref_time(296_353_112 as u64) - // Standard Error: 558_302 - .saturating_add(Weight::from_ref_time(1_012_487 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_050 nanoseconds. + Weight::from_ref_time(303_863_300 as u64) + // Standard Error: 227_870 + .saturating_add(Weight::from_ref_time(235_100 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -547,10 +547,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 295_097 nanoseconds. - Weight::from_ref_time(298_173_380 as u64) - // Standard Error: 325 - .saturating_add(Weight::from_ref_time(191_050 as u64).saturating_mul(n as u64)) + // Minimum execution time: 299_553 nanoseconds. + Weight::from_ref_time(304_972_388 as u64) + // Standard Error: 262 + .saturating_add(Weight::from_ref_time(197_295 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -563,10 +563,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 291_339 nanoseconds. - Weight::from_ref_time(297_328_822 as u64) - // Standard Error: 536_109 - .saturating_add(Weight::from_ref_time(53_529_277 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_708 nanoseconds. + Weight::from_ref_time(306_055_389 as u64) + // Standard Error: 198_678 + .saturating_add(Weight::from_ref_time(57_427_210 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -580,10 +580,10 @@ impl WeightInfo for SubstrateWeight { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 292_833 nanoseconds. - Weight::from_ref_time(303_220_868 as u64) - // Standard Error: 46_963 - .saturating_add(Weight::from_ref_time(108_698_031 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_866 nanoseconds. + Weight::from_ref_time(311_103_336 as u64) + // Standard Error: 38_424 + .saturating_add(Weight::from_ref_time(112_211_212 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -594,10 +594,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 293_111 nanoseconds. - Weight::from_ref_time(304_357_752 as u64) - // Standard Error: 84_942 - .saturating_add(Weight::from_ref_time(218_943_695 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_574 nanoseconds. + Weight::from_ref_time(311_916_564 as u64) + // Standard Error: 62_376 + .saturating_add(Weight::from_ref_time(224_881_274 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -609,12 +609,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_188_981 nanoseconds. - Weight::from_ref_time(494_557_508 as u64) - // Standard Error: 335_039 - .saturating_add(Weight::from_ref_time(176_656_427 as u64).saturating_mul(t as u64)) - // Standard Error: 92_018 - .saturating_add(Weight::from_ref_time(70_000_320 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_234_995 nanoseconds. + Weight::from_ref_time(510_845_948 as u64) + // Standard Error: 447_066 + .saturating_add(Weight::from_ref_time(188_646_130 as u64).saturating_mul(t as u64)) + // Standard Error: 122_786 + .saturating_add(Weight::from_ref_time(72_057_262 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -627,20 +627,20 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 157_568 nanoseconds. - Weight::from_ref_time(161_449_917 as u64) - // Standard Error: 13_938 - .saturating_add(Weight::from_ref_time(12_897_245 as u64).saturating_mul(r as u64)) + // Minimum execution time: 161_631 nanoseconds. + Weight::from_ref_time(164_876_481 as u64) + // Standard Error: 13_873 + .saturating_add(Weight::from_ref_time(13_009_186 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 294_001 nanoseconds. - Weight::from_ref_time(248_958_000 as u64) - // Standard Error: 472_012 - .saturating_add(Weight::from_ref_time(418_368_781 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_039 nanoseconds. + Weight::from_ref_time(251_149_124 as u64) + // Standard Error: 549_293 + .saturating_add(Weight::from_ref_time(445_621_099 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -649,10 +649,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 433_239 nanoseconds. - Weight::from_ref_time(588_857_373 as u64) - // Standard Error: 1_426_031 - .saturating_add(Weight::from_ref_time(92_895_050 as u64).saturating_mul(n as u64)) + // Minimum execution time: 435_530 nanoseconds. + Weight::from_ref_time(614_238_840 as u64) + // Standard Error: 1_623_692 + .saturating_add(Weight::from_ref_time(101_595_333 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(52 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(50 as u64)) @@ -661,10 +661,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 432_591 nanoseconds. - Weight::from_ref_time(563_499_766 as u64) - // Standard Error: 1_212_322 - .saturating_add(Weight::from_ref_time(65_491_920 as u64).saturating_mul(n as u64)) + // Minimum execution time: 436_827 nanoseconds. + Weight::from_ref_time(594_521_125 as u64) + // Standard Error: 1_460_598 + .saturating_add(Weight::from_ref_time(68_080_949 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(49 as u64)) @@ -673,10 +673,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 295_678 nanoseconds. - Weight::from_ref_time(250_903_819 as u64) - // Standard Error: 483_469 - .saturating_add(Weight::from_ref_time(410_221_708 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_911 nanoseconds. + Weight::from_ref_time(252_994_248 as u64) + // Standard Error: 538_853 + .saturating_add(Weight::from_ref_time(438_726_157 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -685,10 +685,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 401_147 nanoseconds. - Weight::from_ref_time(547_029_800 as u64) - // Standard Error: 1_350_158 - .saturating_add(Weight::from_ref_time(66_946_722 as u64).saturating_mul(n as u64)) + // Minimum execution time: 403_401 nanoseconds. + Weight::from_ref_time(577_182_970 as u64) + // Standard Error: 1_589_458 + .saturating_add(Weight::from_ref_time(69_873_104 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -697,10 +697,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 296_061 nanoseconds. - Weight::from_ref_time(257_651_770 as u64) - // Standard Error: 444_344 - .saturating_add(Weight::from_ref_time(329_428_375 as u64).saturating_mul(r as u64)) + // Minimum execution time: 302_119 nanoseconds. + Weight::from_ref_time(265_001_135 as u64) + // Standard Error: 456_550 + .saturating_add(Weight::from_ref_time(358_664_775 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -708,10 +708,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 377_320 nanoseconds. - Weight::from_ref_time(506_517_859 as u64) - // Standard Error: 1_210_985 - .saturating_add(Weight::from_ref_time(154_977_621 as u64).saturating_mul(n as u64)) + // Minimum execution time: 385_096 nanoseconds. + Weight::from_ref_time(537_450_417 as u64) + // Standard Error: 1_425_876 + .saturating_add(Weight::from_ref_time(155_746_820 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -719,10 +719,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 296_753 nanoseconds. - Weight::from_ref_time(260_829_553 as u64) - // Standard Error: 432_834 - .saturating_add(Weight::from_ref_time(317_967_995 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_421 nanoseconds. + Weight::from_ref_time(262_762_745 as u64) + // Standard Error: 497_962 + .saturating_add(Weight::from_ref_time(341_682_818 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -730,10 +730,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 373_049 nanoseconds. - Weight::from_ref_time(484_443_595 as u64) - // Standard Error: 1_048_752 - .saturating_add(Weight::from_ref_time(64_192_391 as u64).saturating_mul(n as u64)) + // Minimum execution time: 379_167 nanoseconds. + Weight::from_ref_time(514_239_503 as u64) + // Standard Error: 1_257_747 + .saturating_add(Weight::from_ref_time(64_734_189 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -741,10 +741,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 297_893 nanoseconds. - Weight::from_ref_time(256_830_685 as u64) - // Standard Error: 436_220 - .saturating_add(Weight::from_ref_time(418_336_409 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_365 nanoseconds. + Weight::from_ref_time(256_283_472 as u64) + // Standard Error: 517_040 + .saturating_add(Weight::from_ref_time(455_679_763 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -753,10 +753,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 402_327 nanoseconds. - Weight::from_ref_time(562_732_190 as u64) - // Standard Error: 1_453_818 - .saturating_add(Weight::from_ref_time(159_662_683 as u64).saturating_mul(n as u64)) + // Minimum execution time: 406_491 nanoseconds. + Weight::from_ref_time(593_727_170 as u64) + // Standard Error: 1_715_624 + .saturating_add(Weight::from_ref_time(163_630_716 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -769,10 +769,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 298_014 nanoseconds. - Weight::from_ref_time(248_052_379 as u64) - // Standard Error: 595_597 - .saturating_add(Weight::from_ref_time(1_341_846_920 as u64).saturating_mul(r as u64)) + // Minimum execution time: 302_533 nanoseconds. + Weight::from_ref_time(266_693_382 as u64) + // Standard Error: 510_705 + .saturating_add(Weight::from_ref_time(1_380_402_053 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -785,10 +785,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 298_250 nanoseconds. - Weight::from_ref_time(299_254_000 as u64) - // Standard Error: 8_061_285 - .saturating_add(Weight::from_ref_time(21_176_072_564 as u64).saturating_mul(r as u64)) + // Minimum execution time: 303_609 nanoseconds. + Weight::from_ref_time(605_684_212 as u64) + // Standard Error: 9_562_866 + .saturating_add(Weight::from_ref_time(20_814_449_121 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -801,10 +801,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 300_286 nanoseconds. - Weight::from_ref_time(505_420_101 as u64) - // Standard Error: 12_020_807 - .saturating_add(Weight::from_ref_time(20_502_779_430 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_036 nanoseconds. + Weight::from_ref_time(299_300_000 as u64) + // Standard Error: 6_617_504 + .saturating_add(Weight::from_ref_time(20_495_640_402 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -818,12 +818,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 9_465_740 nanoseconds. - Weight::from_ref_time(8_443_609_945 as u64) - // Standard Error: 6_130_641 - .saturating_add(Weight::from_ref_time(1_269_904_453 as u64).saturating_mul(t as u64)) - // Standard Error: 9_192 - .saturating_add(Weight::from_ref_time(9_821_368 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_539_055 nanoseconds. + Weight::from_ref_time(8_483_664_501 as u64) + // Standard Error: 7_679_615 + .saturating_add(Weight::from_ref_time(1_308_202_444 as u64).saturating_mul(t as u64)) + // Standard Error: 11_515 + .saturating_add(Weight::from_ref_time(9_772_393 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(167 as u64)) .saturating_add(T::DbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(163 as u64)) @@ -838,10 +838,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 293_708 nanoseconds. - Weight::from_ref_time(294_333_000 as u64) - // Standard Error: 19_087_339 - .saturating_add(Weight::from_ref_time(25_796_470_079 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_735 nanoseconds. + Weight::from_ref_time(297_194_000 as u64) + // Standard Error: 19_981_805 + .saturating_add(Weight::from_ref_time(26_085_707_987 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(5 as u64)) @@ -857,12 +857,10 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 11_500_978 nanoseconds. - Weight::from_ref_time(11_033_266_932 as u64) - // Standard Error: 48_183_801 - .saturating_add(Weight::from_ref_time(36_156_854 as u64).saturating_mul(t as u64)) - // Standard Error: 77_067 - .saturating_add(Weight::from_ref_time(122_691_370 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_604_541 nanoseconds. + Weight::from_ref_time(11_654_911_938 as u64) + // Standard Error: 70_387 + .saturating_add(Weight::from_ref_time(122_480_891 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(249 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(247 as u64)) @@ -875,10 +873,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 287_534 nanoseconds. - Weight::from_ref_time(292_978_777 as u64) - // Standard Error: 612_499 - .saturating_add(Weight::from_ref_time(41_539_022 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_842 nanoseconds. + Weight::from_ref_time(298_528_736 as u64) + // Standard Error: 221_776 + .saturating_add(Weight::from_ref_time(41_330_763 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -889,10 +887,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 331_137 nanoseconds. - Weight::from_ref_time(332_503_000 as u64) - // Standard Error: 56_729 - .saturating_add(Weight::from_ref_time(325_461_347 as u64).saturating_mul(n as u64)) + // Minimum execution time: 335_273 nanoseconds. + Weight::from_ref_time(339_286_000 as u64) + // Standard Error: 60_137 + .saturating_add(Weight::from_ref_time(323_505_025 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -903,10 +901,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 288_957 nanoseconds. - Weight::from_ref_time(292_957_579 as u64) - // Standard Error: 636_977 - .saturating_add(Weight::from_ref_time(60_789_720 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_208 nanoseconds. + Weight::from_ref_time(297_912_167 as u64) + // Standard Error: 145_143 + .saturating_add(Weight::from_ref_time(52_787_732 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -917,10 +915,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 343_123 nanoseconds. - Weight::from_ref_time(343_741_000 as u64) - // Standard Error: 58_203 - .saturating_add(Weight::from_ref_time(247_808_004 as u64).saturating_mul(n as u64)) + // Minimum execution time: 345_905 nanoseconds. + Weight::from_ref_time(350_585_000 as u64) + // Standard Error: 58_069 + .saturating_add(Weight::from_ref_time(247_905_263 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -931,10 +929,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 286_493 nanoseconds. - Weight::from_ref_time(293_256_030 as u64) - // Standard Error: 608_271 - .saturating_add(Weight::from_ref_time(31_193_669 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_053 nanoseconds. + Weight::from_ref_time(297_967_508 as u64) + // Standard Error: 130_197 + .saturating_add(Weight::from_ref_time(32_326_891 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -945,10 +943,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 321_692 nanoseconds. - Weight::from_ref_time(322_518_000 as u64) - // Standard Error: 50_856 - .saturating_add(Weight::from_ref_time(99_851_120 as u64).saturating_mul(n as u64)) + // Minimum execution time: 324_904 nanoseconds. + Weight::from_ref_time(329_481_000 as u64) + // Standard Error: 51_824 + .saturating_add(Weight::from_ref_time(99_701_756 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -959,10 +957,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 285_829 nanoseconds. - Weight::from_ref_time(291_929_059 as u64) - // Standard Error: 609_982 - .saturating_add(Weight::from_ref_time(30_437_840 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_563 nanoseconds. + Weight::from_ref_time(296_961_751 as u64) + // Standard Error: 234_387 + .saturating_add(Weight::from_ref_time(30_922_648 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -973,10 +971,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 320_218 nanoseconds. - Weight::from_ref_time(320_820_000 as u64) - // Standard Error: 49_721 - .saturating_add(Weight::from_ref_time(99_723_926 as u64).saturating_mul(n as u64)) + // Minimum execution time: 323_485 nanoseconds. + Weight::from_ref_time(328_169_000 as u64) + // Standard Error: 49_606 + .saturating_add(Weight::from_ref_time(99_726_280 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -987,10 +985,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 287_068 nanoseconds. - Weight::from_ref_time(294_064_673 as u64) - // Standard Error: 818_242 - .saturating_add(Weight::from_ref_time(3_038_409_926 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_611 nanoseconds. + Weight::from_ref_time(299_478_153 as u64) + // Standard Error: 466_179 + .saturating_add(Weight::from_ref_time(3_032_914_046 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1001,10 +999,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 287_271 nanoseconds. - Weight::from_ref_time(293_100_328 as u64) - // Standard Error: 658_900 - .saturating_add(Weight::from_ref_time(2_070_519_571 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_544 nanoseconds. + Weight::from_ref_time(299_101_359 as u64) + // Standard Error: 435_234 + .saturating_add(Weight::from_ref_time(2_043_545_340 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1015,11 +1013,11 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. - fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 289_181 nanoseconds. - Weight::from_ref_time(290_618_000 as u64) - // Standard Error: 2_652_670 - .saturating_add(Weight::from_ref_time(1_362_797_408 as u64).saturating_mul(r as u64)) + fn seal_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 293_390 nanoseconds. + Weight::from_ref_time(297_791_000 as u64) + // Standard Error: 2_704_135 + .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -1031,11 +1029,11 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 290_954 nanoseconds. - Weight::from_ref_time(295_190_436 as u64) - // Standard Error: 40_295 - .saturating_add(Weight::from_ref_time(11_022_974 as u64).saturating_mul(r as u64)) + fn seal_account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 294_837 nanoseconds. + Weight::from_ref_time(304_337_243 as u64) + // Standard Error: 43_642 + .saturating_add(Weight::from_ref_time(10_830_982 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1045,370 +1043,370 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 292_817 nanoseconds. - Weight::from_ref_time(331_195_835 as u64) - // Standard Error: 126_642 - .saturating_add(Weight::from_ref_time(25_590_472 as u64).saturating_mul(r as u64)) + fn account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 294_852 nanoseconds. + Weight::from_ref_time(343_714_525 as u64) + // Standard Error: 140_657 + .saturating_add(Weight::from_ref_time(24_444_391 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 605 nanoseconds. - Weight::from_ref_time(866_109 as u64) - // Standard Error: 275 - .saturating_add(Weight::from_ref_time(346_136 as u64).saturating_mul(r as u64)) + // Minimum execution time: 631 nanoseconds. + Weight::from_ref_time(864_351 as u64) + // Standard Error: 211 + .saturating_add(Weight::from_ref_time(345_348 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 718 nanoseconds. - Weight::from_ref_time(1_402_372 as u64) - // Standard Error: 2_693 - .saturating_add(Weight::from_ref_time(985_910 as u64).saturating_mul(r as u64)) + // Minimum execution time: 789 nanoseconds. + Weight::from_ref_time(1_394_539 as u64) + // Standard Error: 1_038 + .saturating_add(Weight::from_ref_time(971_005 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 706 nanoseconds. - Weight::from_ref_time(1_120_197 as u64) - // Standard Error: 394 - .saturating_add(Weight::from_ref_time(889_593 as u64).saturating_mul(r as u64)) + // Minimum execution time: 754 nanoseconds. + Weight::from_ref_time(1_128_787 as u64) + // Standard Error: 233 + .saturating_add(Weight::from_ref_time(878_596 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 644 nanoseconds. - Weight::from_ref_time(1_057_422 as u64) - // Standard Error: 857 - .saturating_add(Weight::from_ref_time(955_777 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(934_834 as u64) + // Standard Error: 342 + .saturating_add(Weight::from_ref_time(960_187 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 637 nanoseconds. - Weight::from_ref_time(629_141 as u64) - // Standard Error: 544 - .saturating_add(Weight::from_ref_time(1_293_126 as u64).saturating_mul(r as u64)) + // Minimum execution time: 627 nanoseconds. + Weight::from_ref_time(598_327 as u64) + // Standard Error: 504 + .saturating_add(Weight::from_ref_time(1_302_709 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(1_113_576 as u64) - // Standard Error: 880 - .saturating_add(Weight::from_ref_time(527_673 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(1_125_699 as u64) + // Standard Error: 838 + .saturating_add(Weight::from_ref_time(533_809 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 624 nanoseconds. - Weight::from_ref_time(170_717 as u64) - // Standard Error: 1_959 - .saturating_add(Weight::from_ref_time(867_748 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(1_055_669 as u64) + // Standard Error: 2_735 + .saturating_add(Weight::from_ref_time(805_830 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 648 nanoseconds. - Weight::from_ref_time(539_108 as u64) - // Standard Error: 1_490 - .saturating_add(Weight::from_ref_time(1_077_401 as u64).saturating_mul(r as u64)) + // Minimum execution time: 687 nanoseconds. + Weight::from_ref_time(543_603 as u64) + // Standard Error: 1_877 + .saturating_add(Weight::from_ref_time(1_083_080 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 2_179 nanoseconds. - Weight::from_ref_time(2_597_080 as u64) - // Standard Error: 74 - .saturating_add(Weight::from_ref_time(4_865 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_143 nanoseconds. + Weight::from_ref_time(2_592_361 as u64) + // Standard Error: 76 + .saturating_add(Weight::from_ref_time(4_980 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 633 nanoseconds. - Weight::from_ref_time(1_498_082 as u64) - // Standard Error: 1_780 - .saturating_add(Weight::from_ref_time(2_198_342 as u64).saturating_mul(r as u64)) + // Minimum execution time: 662 nanoseconds. + Weight::from_ref_time(1_475_621 as u64) + // Standard Error: 2_062 + .saturating_add(Weight::from_ref_time(2_201_208 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 806 nanoseconds. - Weight::from_ref_time(1_904_912 as u64) - // Standard Error: 1_182 - .saturating_add(Weight::from_ref_time(2_801_959 as u64).saturating_mul(r as u64)) + // Minimum execution time: 814 nanoseconds. + Weight::from_ref_time(1_978_277 as u64) + // Standard Error: 1_626 + .saturating_add(Weight::from_ref_time(2_816_687 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 4_219 nanoseconds. - Weight::from_ref_time(5_152_036 as u64) - // Standard Error: 290 - .saturating_add(Weight::from_ref_time(179_507 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_200 nanoseconds. + Weight::from_ref_time(5_119_408 as u64) + // Standard Error: 482 + .saturating_add(Weight::from_ref_time(179_490 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 1_438 nanoseconds. - Weight::from_ref_time(1_730_599 as u64) - // Standard Error: 208 - .saturating_add(Weight::from_ref_time(364_842 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_622 nanoseconds. + Weight::from_ref_time(1_884_170 as u64) + // Standard Error: 200 + .saturating_add(Weight::from_ref_time(366_730 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 1_430 nanoseconds. - Weight::from_ref_time(1_671_358 as u64) - // Standard Error: 276 - .saturating_add(Weight::from_ref_time(383_715 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_613 nanoseconds. + Weight::from_ref_time(1_852_996 as u64) + // Standard Error: 180 + .saturating_add(Weight::from_ref_time(383_440 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 1_394 nanoseconds. - Weight::from_ref_time(1_708_668 as u64) - // Standard Error: 199 - .saturating_add(Weight::from_ref_time(526_648 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_556 nanoseconds. + Weight::from_ref_time(1_911_516 as u64) + // Standard Error: 257 + .saturating_add(Weight::from_ref_time(528_015 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 713 nanoseconds. - Weight::from_ref_time(1_095_871 as u64) - // Standard Error: 343 - .saturating_add(Weight::from_ref_time(811_365 as u64).saturating_mul(r as u64)) + // Minimum execution time: 722 nanoseconds. + Weight::from_ref_time(1_079_902 as u64) + // Standard Error: 757 + .saturating_add(Weight::from_ref_time(816_335 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 727 nanoseconds. - Weight::from_ref_time(1_056_556 as u64) - // Standard Error: 355 - .saturating_add(Weight::from_ref_time(830_505 as u64).saturating_mul(r as u64)) + // Minimum execution time: 736 nanoseconds. + Weight::from_ref_time(989_270 as u64) + // Standard Error: 384 + .saturating_add(Weight::from_ref_time(831_122 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 753 nanoseconds. - Weight::from_ref_time(1_004_624 as u64) - // Standard Error: 259 - .saturating_add(Weight::from_ref_time(693_886 as u64).saturating_mul(r as u64)) + // Minimum execution time: 773 nanoseconds. + Weight::from_ref_time(1_086_755 as u64) + // Standard Error: 443 + .saturating_add(Weight::from_ref_time(694_504 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 649 nanoseconds. - Weight::from_ref_time(742_979 as u64) - // Standard Error: 5_852 - .saturating_add(Weight::from_ref_time(184_932_720 as u64).saturating_mul(r as u64)) + // Minimum execution time: 739 nanoseconds. + Weight::from_ref_time(812_861 as u64) + // Standard Error: 5_072 + .saturating_add(Weight::from_ref_time(183_573_238 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 615 nanoseconds. - Weight::from_ref_time(919_735 as u64) - // Standard Error: 443 - .saturating_add(Weight::from_ref_time(509_234 as u64).saturating_mul(r as u64)) + // Minimum execution time: 685 nanoseconds. + Weight::from_ref_time(956_397 as u64) + // Standard Error: 343 + .saturating_add(Weight::from_ref_time(509_878 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 623 nanoseconds. - Weight::from_ref_time(883_408 as u64) - // Standard Error: 437 - .saturating_add(Weight::from_ref_time(517_270 as u64).saturating_mul(r as u64)) + // Minimum execution time: 641 nanoseconds. + Weight::from_ref_time(940_299 as u64) + // Standard Error: 309 + .saturating_add(Weight::from_ref_time(513_853 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 613 nanoseconds. - Weight::from_ref_time(819_503 as u64) - // Standard Error: 704 - .saturating_add(Weight::from_ref_time(518_031 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(924_404 as u64) + // Standard Error: 211 + .saturating_add(Weight::from_ref_time(513_663 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 647 nanoseconds. - Weight::from_ref_time(922_130 as u64) - // Standard Error: 384 - .saturating_add(Weight::from_ref_time(525_187 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(1_021_461 as u64) + // Standard Error: 1_878 + .saturating_add(Weight::from_ref_time(525_934 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 592 nanoseconds. - Weight::from_ref_time(930_340 as u64) - // Standard Error: 277 - .saturating_add(Weight::from_ref_time(505_104 as u64).saturating_mul(r as u64)) + // Minimum execution time: 618 nanoseconds. + Weight::from_ref_time(920_038 as u64) + // Standard Error: 269 + .saturating_add(Weight::from_ref_time(507_263 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 661 nanoseconds. - Weight::from_ref_time(942_938 as u64) - // Standard Error: 268 - .saturating_add(Weight::from_ref_time(504_997 as u64).saturating_mul(r as u64)) + // Minimum execution time: 638 nanoseconds. + Weight::from_ref_time(921_016 as u64) + // Standard Error: 208 + .saturating_add(Weight::from_ref_time(507_276 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 613 nanoseconds. - Weight::from_ref_time(864_875 as u64) - // Standard Error: 720 - .saturating_add(Weight::from_ref_time(508_015 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(918_282 as u64) + // Standard Error: 267 + .saturating_add(Weight::from_ref_time(506_343 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 609 nanoseconds. - Weight::from_ref_time(964_975 as u64) - // Standard Error: 508 - .saturating_add(Weight::from_ref_time(732_494 as u64).saturating_mul(r as u64)) + // Minimum execution time: 683 nanoseconds. + Weight::from_ref_time(912_847 as u64) + // Standard Error: 216 + .saturating_add(Weight::from_ref_time(733_648 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(991_551 as u64) - // Standard Error: 1_126 - .saturating_add(Weight::from_ref_time(731_593 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(937_179 as u64) + // Standard Error: 195 + .saturating_add(Weight::from_ref_time(734_905 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(938_821 as u64) - // Standard Error: 535 - .saturating_add(Weight::from_ref_time(741_527 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(928_242 as u64) + // Standard Error: 197 + .saturating_add(Weight::from_ref_time(741_814 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 634 nanoseconds. - Weight::from_ref_time(969_389 as u64) - // Standard Error: 421 - .saturating_add(Weight::from_ref_time(743_647 as u64).saturating_mul(r as u64)) + // Minimum execution time: 666 nanoseconds. + Weight::from_ref_time(978_908 as u64) + // Standard Error: 212 + .saturating_add(Weight::from_ref_time(743_646 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 620 nanoseconds. - Weight::from_ref_time(997_361 as u64) - // Standard Error: 540 - .saturating_add(Weight::from_ref_time(748_108 as u64).saturating_mul(r as u64)) + // Minimum execution time: 685 nanoseconds. + Weight::from_ref_time(954_961 as u64) + // Standard Error: 215 + .saturating_add(Weight::from_ref_time(747_737 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 586 nanoseconds. - Weight::from_ref_time(966_929 as u64) - // Standard Error: 524 - .saturating_add(Weight::from_ref_time(760_077 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(911_765 as u64) + // Standard Error: 251 + .saturating_add(Weight::from_ref_time(747_195 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 623 nanoseconds. - Weight::from_ref_time(974_811 as u64) - // Standard Error: 528 - .saturating_add(Weight::from_ref_time(745_124 as u64).saturating_mul(r as u64)) + // Minimum execution time: 632 nanoseconds. + Weight::from_ref_time(950_928 as u64) + // Standard Error: 287 + .saturating_add(Weight::from_ref_time(735_938 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(990_326 as u64) - // Standard Error: 535 - .saturating_add(Weight::from_ref_time(808_599 as u64).saturating_mul(r as u64)) + // Minimum execution time: 614 nanoseconds. + Weight::from_ref_time(885_567 as u64) + // Standard Error: 2_216 + .saturating_add(Weight::from_ref_time(747_731 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 600 nanoseconds. - Weight::from_ref_time(969_957 as u64) - // Standard Error: 604 - .saturating_add(Weight::from_ref_time(744_174 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(929_711 as u64) + // Standard Error: 180 + .saturating_add(Weight::from_ref_time(736_449 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 632 nanoseconds. - Weight::from_ref_time(976_250 as u64) - // Standard Error: 938 - .saturating_add(Weight::from_ref_time(798_224 as u64).saturating_mul(r as u64)) + // Minimum execution time: 655 nanoseconds. + Weight::from_ref_time(918_994 as u64) + // Standard Error: 673 + .saturating_add(Weight::from_ref_time(742_317 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 627 nanoseconds. - Weight::from_ref_time(939_131 as u64) - // Standard Error: 457 - .saturating_add(Weight::from_ref_time(718_514 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(925_471 as u64) + // Standard Error: 207 + .saturating_add(Weight::from_ref_time(720_264 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 621 nanoseconds. - Weight::from_ref_time(905_432 as u64) - // Standard Error: 637 - .saturating_add(Weight::from_ref_time(716_365 as u64).saturating_mul(r as u64)) + // Minimum execution time: 630 nanoseconds. + Weight::from_ref_time(915_027 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(715_446 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 610 nanoseconds. - Weight::from_ref_time(926_074 as u64) - // Standard Error: 457 - .saturating_add(Weight::from_ref_time(716_003 as u64).saturating_mul(r as u64)) + // Minimum execution time: 658 nanoseconds. + Weight::from_ref_time(944_559 as u64) + // Standard Error: 190 + .saturating_add(Weight::from_ref_time(715_915 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 595 nanoseconds. - Weight::from_ref_time(1_023_054 as u64) - // Standard Error: 2_584 - .saturating_add(Weight::from_ref_time(1_349_736 as u64).saturating_mul(r as u64)) + // Minimum execution time: 622 nanoseconds. + Weight::from_ref_time(917_324 as u64) + // Standard Error: 447 + .saturating_add(Weight::from_ref_time(1_355_730 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(966_937 as u64) - // Standard Error: 786 - .saturating_add(Weight::from_ref_time(1_284_291 as u64).saturating_mul(r as u64)) + // Minimum execution time: 643 nanoseconds. + Weight::from_ref_time(899_983 as u64) + // Standard Error: 430 + .saturating_add(Weight::from_ref_time(1_285_187 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(972_082 as u64) - // Standard Error: 1_441 - .saturating_add(Weight::from_ref_time(1_403_148 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(896_030 as u64) + // Standard Error: 528 + .saturating_add(Weight::from_ref_time(1_401_764 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 644 nanoseconds. - Weight::from_ref_time(991_706 as u64) - // Standard Error: 1_103 - .saturating_add(Weight::from_ref_time(1_284_545 as u64).saturating_mul(r as u64)) + // Minimum execution time: 609 nanoseconds. + Weight::from_ref_time(859_662 as u64) + // Standard Error: 730 + .saturating_add(Weight::from_ref_time(1_287_681 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 630 nanoseconds. - Weight::from_ref_time(941_587 as u64) - // Standard Error: 506 - .saturating_add(Weight::from_ref_time(719_943 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(902_285 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(721_017 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 624 nanoseconds. - Weight::from_ref_time(939_991 as u64) - // Standard Error: 520 - .saturating_add(Weight::from_ref_time(719_994 as u64).saturating_mul(r as u64)) + // Minimum execution time: 682 nanoseconds. + Weight::from_ref_time(957_929 as u64) + // Standard Error: 235 + .saturating_add(Weight::from_ref_time(718_864 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 609 nanoseconds. - Weight::from_ref_time(970_308 as u64) - // Standard Error: 552 - .saturating_add(Weight::from_ref_time(719_566 as u64).saturating_mul(r as u64)) + // Minimum execution time: 637 nanoseconds. + Weight::from_ref_time(793_291 as u64) + // Standard Error: 601 + .saturating_add(Weight::from_ref_time(727_384 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 613 nanoseconds. - Weight::from_ref_time(920_835 as u64) - // Standard Error: 623 - .saturating_add(Weight::from_ref_time(737_690 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(974_702 as u64) + // Standard Error: 350 + .saturating_add(Weight::from_ref_time(736_068 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 626 nanoseconds. - Weight::from_ref_time(919_030 as u64) - // Standard Error: 486 - .saturating_add(Weight::from_ref_time(737_096 as u64).saturating_mul(r as u64)) + // Minimum execution time: 636 nanoseconds. + Weight::from_ref_time(900_404 as u64) + // Standard Error: 355 + .saturating_add(Weight::from_ref_time(738_519 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 634 nanoseconds. - Weight::from_ref_time(964_779 as u64) - // Standard Error: 496 - .saturating_add(Weight::from_ref_time(736_322 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(1_000_078 as u64) + // Standard Error: 340 + .saturating_add(Weight::from_ref_time(735_680 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 631 nanoseconds. - Weight::from_ref_time(918_768 as u64) - // Standard Error: 952 - .saturating_add(Weight::from_ref_time(740_280 as u64).saturating_mul(r as u64)) + // Minimum execution time: 621 nanoseconds. + Weight::from_ref_time(933_845 as u64) + // Standard Error: 194 + .saturating_add(Weight::from_ref_time(736_788 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 639 nanoseconds. - Weight::from_ref_time(955_994 as u64) - // Standard Error: 523 - .saturating_add(Weight::from_ref_time(738_232 as u64).saturating_mul(r as u64)) + // Minimum execution time: 640 nanoseconds. + Weight::from_ref_time(932_522 as u64) + // Standard Error: 262 + .saturating_add(Weight::from_ref_time(736_535 as u64).saturating_mul(r as u64)) } } @@ -1416,17 +1414,17 @@ impl WeightInfo for SubstrateWeight { impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 3_092 nanoseconds. - Weight::from_ref_time(3_273_000 as u64) + // Minimum execution time: 3_254 nanoseconds. + Weight::from_ref_time(3_367_000 as u64) .saturating_add(RocksDbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 15_553 nanoseconds. - Weight::from_ref_time(17_898_219 as u64) - // Standard Error: 612 - .saturating_add(Weight::from_ref_time(959_535 as u64).saturating_mul(k as u64)) + // Minimum execution time: 16_206 nanoseconds. + Weight::from_ref_time(19_434_064 as u64) + // Standard Error: 715 + .saturating_add(Weight::from_ref_time(963_296 as u64).saturating_mul(k as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) .saturating_add(RocksDbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -1434,10 +1432,10 @@ impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 3_051 nanoseconds. - Weight::from_ref_time(16_045_885 as u64) - // Standard Error: 3_894 - .saturating_add(Weight::from_ref_time(1_251_095 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_130 nanoseconds. + Weight::from_ref_time(18_640_668 as u64) + // Standard Error: 4_357 + .saturating_add(Weight::from_ref_time(1_274_044 as u64).saturating_mul(q as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1445,10 +1443,10 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 29_767 nanoseconds. - Weight::from_ref_time(24_442_384 as u64) - // Standard Error: 41 - .saturating_add(Weight::from_ref_time(47_060 as u64).saturating_mul(c as u64)) + // Minimum execution time: 29_419 nanoseconds. + Weight::from_ref_time(20_616_893 as u64) + // Standard Error: 44 + .saturating_add(Weight::from_ref_time(47_249 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1459,10 +1457,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 307_279 nanoseconds. - Weight::from_ref_time(317_807_474 as u64) - // Standard Error: 17 - .saturating_add(Weight::from_ref_time(30_874 as u64).saturating_mul(c as u64)) + // Minimum execution time: 311_735 nanoseconds. + Weight::from_ref_time(324_179_000 as u64) + // Standard Error: 23 + .saturating_add(Weight::from_ref_time(31_787 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1477,12 +1475,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_173_376 nanoseconds. - Weight::from_ref_time(333_991_198 as u64) - // Standard Error: 47 - .saturating_add(Weight::from_ref_time(90_283 as u64).saturating_mul(c as u64)) - // Standard Error: 2 - .saturating_add(Weight::from_ref_time(1_782 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_187_833 nanoseconds. + Weight::from_ref_time(419_021_666 as u64) + // Standard Error: 64 + .saturating_add(Weight::from_ref_time(91_150 as u64).saturating_mul(c as u64)) + // Standard Error: 3 + .saturating_add(Weight::from_ref_time(1_767 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(9 as u64)) } @@ -1495,10 +1493,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 187_549 nanoseconds. - Weight::from_ref_time(176_268_968 as u64) - // Standard Error: 1 - .saturating_add(Weight::from_ref_time(1_525 as u64).saturating_mul(s as u64)) + // Minimum execution time: 193_073 nanoseconds. + Weight::from_ref_time(177_294_408 as u64) + // Standard Error: 2 + .saturating_add(Weight::from_ref_time(1_563 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(7 as u64)) } @@ -1508,8 +1506,8 @@ impl WeightInfo for () { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 156_476 nanoseconds. - Weight::from_ref_time(157_462_000 as u64) + // Minimum execution time: 160_898 nanoseconds. + Weight::from_ref_time(161_990_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1519,10 +1517,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 295_320 nanoseconds. - Weight::from_ref_time(305_011_007 as u64) - // Standard Error: 53 - .saturating_add(Weight::from_ref_time(77_528 as u64).saturating_mul(c as u64)) + // Minimum execution time: 305_859 nanoseconds. + Weight::from_ref_time(309_986_743 as u64) + // Standard Error: 65 + .saturating_add(Weight::from_ref_time(91_731 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1531,8 +1529,8 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 39_868 nanoseconds. - Weight::from_ref_time(40_885_000 as u64) + // Minimum execution time: 41_544 nanoseconds. + Weight::from_ref_time(41_956_000 as u64) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1540,8 +1538,8 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 42_082 nanoseconds. - Weight::from_ref_time(42_487_000 as u64) + // Minimum execution time: 43_313 nanoseconds. + Weight::from_ref_time(43_987_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(6 as u64)) } @@ -1552,10 +1550,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 295_276 nanoseconds. - Weight::from_ref_time(300_528_395 as u64) - // Standard Error: 22_438 - .saturating_add(Weight::from_ref_time(16_661_252 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_251 nanoseconds. + Weight::from_ref_time(308_118_154 as u64) + // Standard Error: 13_919 + .saturating_add(Weight::from_ref_time(16_555_470 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1566,10 +1564,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 296_022 nanoseconds. - Weight::from_ref_time(231_263_577 as u64) - // Standard Error: 430_945 - .saturating_add(Weight::from_ref_time(199_389_344 as u64).saturating_mul(r as u64)) + // Minimum execution time: 302_090 nanoseconds. + Weight::from_ref_time(237_951_992 as u64) + // Standard Error: 425_584 + .saturating_add(Weight::from_ref_time(213_514_628 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1581,10 +1579,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 297_796 nanoseconds. - Weight::from_ref_time(243_158_249 as u64) - // Standard Error: 396_560 - .saturating_add(Weight::from_ref_time(242_784_462 as u64).saturating_mul(r as u64)) + // Minimum execution time: 303_203 nanoseconds. + Weight::from_ref_time(263_005_297 as u64) + // Standard Error: 376_919 + .saturating_add(Weight::from_ref_time(265_396_805 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1596,10 +1594,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 297_206 nanoseconds. - Weight::from_ref_time(302_423_708 as u64) - // Standard Error: 18_660 - .saturating_add(Weight::from_ref_time(20_507_825 as u64).saturating_mul(r as u64)) + // Minimum execution time: 304_113 nanoseconds. + Weight::from_ref_time(311_754_829 as u64) + // Standard Error: 18_343 + .saturating_add(Weight::from_ref_time(19_940_285 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1610,10 +1608,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 293_337 nanoseconds. - Weight::from_ref_time(298_462_585 as u64) - // Standard Error: 15_979 - .saturating_add(Weight::from_ref_time(11_165_786 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_259 nanoseconds. + Weight::from_ref_time(308_994_291 as u64) + // Standard Error: 14_116 + .saturating_add(Weight::from_ref_time(11_176_417 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1624,10 +1622,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 294_982 nanoseconds. - Weight::from_ref_time(299_538_930 as u64) - // Standard Error: 18_777 - .saturating_add(Weight::from_ref_time(16_575_318 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_414 nanoseconds. + Weight::from_ref_time(310_130_007 as u64) + // Standard Error: 21_977 + .saturating_add(Weight::from_ref_time(16_288_617 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1638,10 +1636,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 295_266 nanoseconds. - Weight::from_ref_time(301_023_294 as u64) - // Standard Error: 18_987 - .saturating_add(Weight::from_ref_time(16_152_668 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_342 nanoseconds. + Weight::from_ref_time(308_941_812 as u64) + // Standard Error: 15_417 + .saturating_add(Weight::from_ref_time(16_046_689 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1652,10 +1650,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 293_847 nanoseconds. - Weight::from_ref_time(302_991_846 as u64) - // Standard Error: 36_830 - .saturating_add(Weight::from_ref_time(89_091_598 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_133 nanoseconds. + Weight::from_ref_time(311_277_478 as u64) + // Standard Error: 35_954 + .saturating_add(Weight::from_ref_time(97_275_936 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1666,10 +1664,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 295_907 nanoseconds. - Weight::from_ref_time(300_322_285 as u64) - // Standard Error: 20_612 - .saturating_add(Weight::from_ref_time(16_199_834 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_980 nanoseconds. + Weight::from_ref_time(308_487_901 as u64) + // Standard Error: 15_791 + .saturating_add(Weight::from_ref_time(15_971_242 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1680,10 +1678,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 295_042 nanoseconds. - Weight::from_ref_time(299_750_507 as u64) - // Standard Error: 19_981 - .saturating_add(Weight::from_ref_time(16_290_215 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_042 nanoseconds. + Weight::from_ref_time(308_378_169 as u64) + // Standard Error: 13_644 + .saturating_add(Weight::from_ref_time(15_940_362 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1694,10 +1692,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 295_129 nanoseconds. - Weight::from_ref_time(301_389_224 as u64) - // Standard Error: 20_956 - .saturating_add(Weight::from_ref_time(15_947_448 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_913 nanoseconds. + Weight::from_ref_time(306_528_553 as u64) + // Standard Error: 18_702 + .saturating_add(Weight::from_ref_time(16_259_237 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1708,10 +1706,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 295_128 nanoseconds. - Weight::from_ref_time(299_569_582 as u64) - // Standard Error: 18_853 - .saturating_add(Weight::from_ref_time(16_304_774 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_639 nanoseconds. + Weight::from_ref_time(310_298_448 as u64) + // Standard Error: 20_201 + .saturating_add(Weight::from_ref_time(15_923_667 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1723,10 +1721,10 @@ impl WeightInfo for () { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 295_229 nanoseconds. - Weight::from_ref_time(305_986_569 as u64) - // Standard Error: 33_339 - .saturating_add(Weight::from_ref_time(85_497_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_200 nanoseconds. + Weight::from_ref_time(312_744_329 as u64) + // Standard Error: 33_748 + .saturating_add(Weight::from_ref_time(88_361_056 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1737,10 +1735,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 144_560 nanoseconds. - Weight::from_ref_time(147_780_996 as u64) - // Standard Error: 8_658 - .saturating_add(Weight::from_ref_time(8_185_717 as u64).saturating_mul(r as u64)) + // Minimum execution time: 148_130 nanoseconds. + Weight::from_ref_time(151_542_553 as u64) + // Standard Error: 9_571 + .saturating_add(Weight::from_ref_time(8_134_705 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1751,10 +1749,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 291_869 nanoseconds. - Weight::from_ref_time(300_501_085 as u64) - // Standard Error: 17_955 - .saturating_add(Weight::from_ref_time(13_899_691 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_987 nanoseconds. + Weight::from_ref_time(307_696_695 as u64) + // Standard Error: 15_723 + .saturating_add(Weight::from_ref_time(14_189_895 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1765,10 +1763,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 312_247 nanoseconds. - Weight::from_ref_time(327_623_543 as u64) - // Standard Error: 1_162 - .saturating_add(Weight::from_ref_time(9_752_573 as u64).saturating_mul(n as u64)) + // Minimum execution time: 318_276 nanoseconds. + Weight::from_ref_time(335_793_925 as u64) + // Standard Error: 1_344 + .saturating_add(Weight::from_ref_time(9_778_604 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1779,10 +1777,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 290_105 nanoseconds. - Weight::from_ref_time(296_353_112 as u64) - // Standard Error: 558_302 - .saturating_add(Weight::from_ref_time(1_012_487 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_050 nanoseconds. + Weight::from_ref_time(303_863_300 as u64) + // Standard Error: 227_870 + .saturating_add(Weight::from_ref_time(235_100 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1793,10 +1791,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 295_097 nanoseconds. - Weight::from_ref_time(298_173_380 as u64) - // Standard Error: 325 - .saturating_add(Weight::from_ref_time(191_050 as u64).saturating_mul(n as u64)) + // Minimum execution time: 299_553 nanoseconds. + Weight::from_ref_time(304_972_388 as u64) + // Standard Error: 262 + .saturating_add(Weight::from_ref_time(197_295 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1809,10 +1807,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 291_339 nanoseconds. - Weight::from_ref_time(297_328_822 as u64) - // Standard Error: 536_109 - .saturating_add(Weight::from_ref_time(53_529_277 as u64).saturating_mul(r as u64)) + // Minimum execution time: 299_708 nanoseconds. + Weight::from_ref_time(306_055_389 as u64) + // Standard Error: 198_678 + .saturating_add(Weight::from_ref_time(57_427_210 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1826,10 +1824,10 @@ impl WeightInfo for () { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 292_833 nanoseconds. - Weight::from_ref_time(303_220_868 as u64) - // Standard Error: 46_963 - .saturating_add(Weight::from_ref_time(108_698_031 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_866 nanoseconds. + Weight::from_ref_time(311_103_336 as u64) + // Standard Error: 38_424 + .saturating_add(Weight::from_ref_time(112_211_212 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1840,10 +1838,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 293_111 nanoseconds. - Weight::from_ref_time(304_357_752 as u64) - // Standard Error: 84_942 - .saturating_add(Weight::from_ref_time(218_943_695 as u64).saturating_mul(r as u64)) + // Minimum execution time: 297_574 nanoseconds. + Weight::from_ref_time(311_916_564 as u64) + // Standard Error: 62_376 + .saturating_add(Weight::from_ref_time(224_881_274 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1855,12 +1853,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_188_981 nanoseconds. - Weight::from_ref_time(494_557_508 as u64) - // Standard Error: 335_039 - .saturating_add(Weight::from_ref_time(176_656_427 as u64).saturating_mul(t as u64)) - // Standard Error: 92_018 - .saturating_add(Weight::from_ref_time(70_000_320 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_234_995 nanoseconds. + Weight::from_ref_time(510_845_948 as u64) + // Standard Error: 447_066 + .saturating_add(Weight::from_ref_time(188_646_130 as u64).saturating_mul(t as u64)) + // Standard Error: 122_786 + .saturating_add(Weight::from_ref_time(72_057_262 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1873,20 +1871,20 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 157_568 nanoseconds. - Weight::from_ref_time(161_449_917 as u64) - // Standard Error: 13_938 - .saturating_add(Weight::from_ref_time(12_897_245 as u64).saturating_mul(r as u64)) + // Minimum execution time: 161_631 nanoseconds. + Weight::from_ref_time(164_876_481 as u64) + // Standard Error: 13_873 + .saturating_add(Weight::from_ref_time(13_009_186 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 294_001 nanoseconds. - Weight::from_ref_time(248_958_000 as u64) - // Standard Error: 472_012 - .saturating_add(Weight::from_ref_time(418_368_781 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_039 nanoseconds. + Weight::from_ref_time(251_149_124 as u64) + // Standard Error: 549_293 + .saturating_add(Weight::from_ref_time(445_621_099 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1895,10 +1893,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 433_239 nanoseconds. - Weight::from_ref_time(588_857_373 as u64) - // Standard Error: 1_426_031 - .saturating_add(Weight::from_ref_time(92_895_050 as u64).saturating_mul(n as u64)) + // Minimum execution time: 435_530 nanoseconds. + Weight::from_ref_time(614_238_840 as u64) + // Standard Error: 1_623_692 + .saturating_add(Weight::from_ref_time(101_595_333 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(52 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(50 as u64)) @@ -1907,10 +1905,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 432_591 nanoseconds. - Weight::from_ref_time(563_499_766 as u64) - // Standard Error: 1_212_322 - .saturating_add(Weight::from_ref_time(65_491_920 as u64).saturating_mul(n as u64)) + // Minimum execution time: 436_827 nanoseconds. + Weight::from_ref_time(594_521_125 as u64) + // Standard Error: 1_460_598 + .saturating_add(Weight::from_ref_time(68_080_949 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(49 as u64)) @@ -1919,10 +1917,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 295_678 nanoseconds. - Weight::from_ref_time(250_903_819 as u64) - // Standard Error: 483_469 - .saturating_add(Weight::from_ref_time(410_221_708 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_911 nanoseconds. + Weight::from_ref_time(252_994_248 as u64) + // Standard Error: 538_853 + .saturating_add(Weight::from_ref_time(438_726_157 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1931,10 +1929,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 401_147 nanoseconds. - Weight::from_ref_time(547_029_800 as u64) - // Standard Error: 1_350_158 - .saturating_add(Weight::from_ref_time(66_946_722 as u64).saturating_mul(n as u64)) + // Minimum execution time: 403_401 nanoseconds. + Weight::from_ref_time(577_182_970 as u64) + // Standard Error: 1_589_458 + .saturating_add(Weight::from_ref_time(69_873_104 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -1943,10 +1941,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 296_061 nanoseconds. - Weight::from_ref_time(257_651_770 as u64) - // Standard Error: 444_344 - .saturating_add(Weight::from_ref_time(329_428_375 as u64).saturating_mul(r as u64)) + // Minimum execution time: 302_119 nanoseconds. + Weight::from_ref_time(265_001_135 as u64) + // Standard Error: 456_550 + .saturating_add(Weight::from_ref_time(358_664_775 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1954,10 +1952,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 377_320 nanoseconds. - Weight::from_ref_time(506_517_859 as u64) - // Standard Error: 1_210_985 - .saturating_add(Weight::from_ref_time(154_977_621 as u64).saturating_mul(n as u64)) + // Minimum execution time: 385_096 nanoseconds. + Weight::from_ref_time(537_450_417 as u64) + // Standard Error: 1_425_876 + .saturating_add(Weight::from_ref_time(155_746_820 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1965,10 +1963,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 296_753 nanoseconds. - Weight::from_ref_time(260_829_553 as u64) - // Standard Error: 432_834 - .saturating_add(Weight::from_ref_time(317_967_995 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_421 nanoseconds. + Weight::from_ref_time(262_762_745 as u64) + // Standard Error: 497_962 + .saturating_add(Weight::from_ref_time(341_682_818 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1976,10 +1974,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 373_049 nanoseconds. - Weight::from_ref_time(484_443_595 as u64) - // Standard Error: 1_048_752 - .saturating_add(Weight::from_ref_time(64_192_391 as u64).saturating_mul(n as u64)) + // Minimum execution time: 379_167 nanoseconds. + Weight::from_ref_time(514_239_503 as u64) + // Standard Error: 1_257_747 + .saturating_add(Weight::from_ref_time(64_734_189 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1987,10 +1985,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 297_893 nanoseconds. - Weight::from_ref_time(256_830_685 as u64) - // Standard Error: 436_220 - .saturating_add(Weight::from_ref_time(418_336_409 as u64).saturating_mul(r as u64)) + // Minimum execution time: 300_365 nanoseconds. + Weight::from_ref_time(256_283_472 as u64) + // Standard Error: 517_040 + .saturating_add(Weight::from_ref_time(455_679_763 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1999,10 +1997,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 402_327 nanoseconds. - Weight::from_ref_time(562_732_190 as u64) - // Standard Error: 1_453_818 - .saturating_add(Weight::from_ref_time(159_662_683 as u64).saturating_mul(n as u64)) + // Minimum execution time: 406_491 nanoseconds. + Weight::from_ref_time(593_727_170 as u64) + // Standard Error: 1_715_624 + .saturating_add(Weight::from_ref_time(163_630_716 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -2015,10 +2013,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 298_014 nanoseconds. - Weight::from_ref_time(248_052_379 as u64) - // Standard Error: 595_597 - .saturating_add(Weight::from_ref_time(1_341_846_920 as u64).saturating_mul(r as u64)) + // Minimum execution time: 302_533 nanoseconds. + Weight::from_ref_time(266_693_382 as u64) + // Standard Error: 510_705 + .saturating_add(Weight::from_ref_time(1_380_402_053 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(4 as u64)) @@ -2031,10 +2029,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 298_250 nanoseconds. - Weight::from_ref_time(299_254_000 as u64) - // Standard Error: 8_061_285 - .saturating_add(Weight::from_ref_time(21_176_072_564 as u64).saturating_mul(r as u64)) + // Minimum execution time: 303_609 nanoseconds. + Weight::from_ref_time(605_684_212 as u64) + // Standard Error: 9_562_866 + .saturating_add(Weight::from_ref_time(20_814_449_121 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2047,10 +2045,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 300_286 nanoseconds. - Weight::from_ref_time(505_420_101 as u64) - // Standard Error: 12_020_807 - .saturating_add(Weight::from_ref_time(20_502_779_430 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_036 nanoseconds. + Weight::from_ref_time(299_300_000 as u64) + // Standard Error: 6_617_504 + .saturating_add(Weight::from_ref_time(20_495_640_402 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2064,12 +2062,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 9_465_740 nanoseconds. - Weight::from_ref_time(8_443_609_945 as u64) - // Standard Error: 6_130_641 - .saturating_add(Weight::from_ref_time(1_269_904_453 as u64).saturating_mul(t as u64)) - // Standard Error: 9_192 - .saturating_add(Weight::from_ref_time(9_821_368 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_539_055 nanoseconds. + Weight::from_ref_time(8_483_664_501 as u64) + // Standard Error: 7_679_615 + .saturating_add(Weight::from_ref_time(1_308_202_444 as u64).saturating_mul(t as u64)) + // Standard Error: 11_515 + .saturating_add(Weight::from_ref_time(9_772_393 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(167 as u64)) .saturating_add(RocksDbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(163 as u64)) @@ -2084,10 +2082,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 293_708 nanoseconds. - Weight::from_ref_time(294_333_000 as u64) - // Standard Error: 19_087_339 - .saturating_add(Weight::from_ref_time(25_796_470_079 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_735 nanoseconds. + Weight::from_ref_time(297_194_000 as u64) + // Standard Error: 19_981_805 + .saturating_add(Weight::from_ref_time(26_085_707_987 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(5 as u64)) @@ -2103,12 +2101,10 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 11_500_978 nanoseconds. - Weight::from_ref_time(11_033_266_932 as u64) - // Standard Error: 48_183_801 - .saturating_add(Weight::from_ref_time(36_156_854 as u64).saturating_mul(t as u64)) - // Standard Error: 77_067 - .saturating_add(Weight::from_ref_time(122_691_370 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_604_541 nanoseconds. + Weight::from_ref_time(11_654_911_938 as u64) + // Standard Error: 70_387 + .saturating_add(Weight::from_ref_time(122_480_891 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(249 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(247 as u64)) @@ -2121,10 +2117,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 287_534 nanoseconds. - Weight::from_ref_time(292_978_777 as u64) - // Standard Error: 612_499 - .saturating_add(Weight::from_ref_time(41_539_022 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_842 nanoseconds. + Weight::from_ref_time(298_528_736 as u64) + // Standard Error: 221_776 + .saturating_add(Weight::from_ref_time(41_330_763 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2135,10 +2131,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 331_137 nanoseconds. - Weight::from_ref_time(332_503_000 as u64) - // Standard Error: 56_729 - .saturating_add(Weight::from_ref_time(325_461_347 as u64).saturating_mul(n as u64)) + // Minimum execution time: 335_273 nanoseconds. + Weight::from_ref_time(339_286_000 as u64) + // Standard Error: 60_137 + .saturating_add(Weight::from_ref_time(323_505_025 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2149,10 +2145,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 288_957 nanoseconds. - Weight::from_ref_time(292_957_579 as u64) - // Standard Error: 636_977 - .saturating_add(Weight::from_ref_time(60_789_720 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_208 nanoseconds. + Weight::from_ref_time(297_912_167 as u64) + // Standard Error: 145_143 + .saturating_add(Weight::from_ref_time(52_787_732 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2163,10 +2159,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 343_123 nanoseconds. - Weight::from_ref_time(343_741_000 as u64) - // Standard Error: 58_203 - .saturating_add(Weight::from_ref_time(247_808_004 as u64).saturating_mul(n as u64)) + // Minimum execution time: 345_905 nanoseconds. + Weight::from_ref_time(350_585_000 as u64) + // Standard Error: 58_069 + .saturating_add(Weight::from_ref_time(247_905_263 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2177,10 +2173,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 286_493 nanoseconds. - Weight::from_ref_time(293_256_030 as u64) - // Standard Error: 608_271 - .saturating_add(Weight::from_ref_time(31_193_669 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_053 nanoseconds. + Weight::from_ref_time(297_967_508 as u64) + // Standard Error: 130_197 + .saturating_add(Weight::from_ref_time(32_326_891 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2191,10 +2187,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 321_692 nanoseconds. - Weight::from_ref_time(322_518_000 as u64) - // Standard Error: 50_856 - .saturating_add(Weight::from_ref_time(99_851_120 as u64).saturating_mul(n as u64)) + // Minimum execution time: 324_904 nanoseconds. + Weight::from_ref_time(329_481_000 as u64) + // Standard Error: 51_824 + .saturating_add(Weight::from_ref_time(99_701_756 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2205,10 +2201,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 285_829 nanoseconds. - Weight::from_ref_time(291_929_059 as u64) - // Standard Error: 609_982 - .saturating_add(Weight::from_ref_time(30_437_840 as u64).saturating_mul(r as u64)) + // Minimum execution time: 287_563 nanoseconds. + Weight::from_ref_time(296_961_751 as u64) + // Standard Error: 234_387 + .saturating_add(Weight::from_ref_time(30_922_648 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2219,10 +2215,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 320_218 nanoseconds. - Weight::from_ref_time(320_820_000 as u64) - // Standard Error: 49_721 - .saturating_add(Weight::from_ref_time(99_723_926 as u64).saturating_mul(n as u64)) + // Minimum execution time: 323_485 nanoseconds. + Weight::from_ref_time(328_169_000 as u64) + // Standard Error: 49_606 + .saturating_add(Weight::from_ref_time(99_726_280 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2233,10 +2229,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 287_068 nanoseconds. - Weight::from_ref_time(294_064_673 as u64) - // Standard Error: 818_242 - .saturating_add(Weight::from_ref_time(3_038_409_926 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_611 nanoseconds. + Weight::from_ref_time(299_478_153 as u64) + // Standard Error: 466_179 + .saturating_add(Weight::from_ref_time(3_032_914_046 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2247,10 +2243,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 287_271 nanoseconds. - Weight::from_ref_time(293_100_328 as u64) - // Standard Error: 658_900 - .saturating_add(Weight::from_ref_time(2_070_519_571 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_544 nanoseconds. + Weight::from_ref_time(299_101_359 as u64) + // Standard Error: 435_234 + .saturating_add(Weight::from_ref_time(2_043_545_340 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2261,11 +2257,11 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. - fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 289_181 nanoseconds. - Weight::from_ref_time(290_618_000 as u64) - // Standard Error: 2_652_670 - .saturating_add(Weight::from_ref_time(1_362_797_408 as u64).saturating_mul(r as u64)) + fn seal_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 293_390 nanoseconds. + Weight::from_ref_time(297_791_000 as u64) + // Standard Error: 2_704_135 + .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2277,11 +2273,11 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 290_954 nanoseconds. - Weight::from_ref_time(295_190_436 as u64) - // Standard Error: 40_295 - .saturating_add(Weight::from_ref_time(11_022_974 as u64).saturating_mul(r as u64)) + fn seal_account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 294_837 nanoseconds. + Weight::from_ref_time(304_337_243 as u64) + // Standard Error: 43_642 + .saturating_add(Weight::from_ref_time(10_830_982 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2291,369 +2287,369 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 292_817 nanoseconds. - Weight::from_ref_time(331_195_835 as u64) - // Standard Error: 126_642 - .saturating_add(Weight::from_ref_time(25_590_472 as u64).saturating_mul(r as u64)) + fn account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 294_852 nanoseconds. + Weight::from_ref_time(343_714_525 as u64) + // Standard Error: 140_657 + .saturating_add(Weight::from_ref_time(24_444_391 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 605 nanoseconds. - Weight::from_ref_time(866_109 as u64) - // Standard Error: 275 - .saturating_add(Weight::from_ref_time(346_136 as u64).saturating_mul(r as u64)) + // Minimum execution time: 631 nanoseconds. + Weight::from_ref_time(864_351 as u64) + // Standard Error: 211 + .saturating_add(Weight::from_ref_time(345_348 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 718 nanoseconds. - Weight::from_ref_time(1_402_372 as u64) - // Standard Error: 2_693 - .saturating_add(Weight::from_ref_time(985_910 as u64).saturating_mul(r as u64)) + // Minimum execution time: 789 nanoseconds. + Weight::from_ref_time(1_394_539 as u64) + // Standard Error: 1_038 + .saturating_add(Weight::from_ref_time(971_005 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 706 nanoseconds. - Weight::from_ref_time(1_120_197 as u64) - // Standard Error: 394 - .saturating_add(Weight::from_ref_time(889_593 as u64).saturating_mul(r as u64)) + // Minimum execution time: 754 nanoseconds. + Weight::from_ref_time(1_128_787 as u64) + // Standard Error: 233 + .saturating_add(Weight::from_ref_time(878_596 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 644 nanoseconds. - Weight::from_ref_time(1_057_422 as u64) - // Standard Error: 857 - .saturating_add(Weight::from_ref_time(955_777 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(934_834 as u64) + // Standard Error: 342 + .saturating_add(Weight::from_ref_time(960_187 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 637 nanoseconds. - Weight::from_ref_time(629_141 as u64) - // Standard Error: 544 - .saturating_add(Weight::from_ref_time(1_293_126 as u64).saturating_mul(r as u64)) + // Minimum execution time: 627 nanoseconds. + Weight::from_ref_time(598_327 as u64) + // Standard Error: 504 + .saturating_add(Weight::from_ref_time(1_302_709 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(1_113_576 as u64) - // Standard Error: 880 - .saturating_add(Weight::from_ref_time(527_673 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(1_125_699 as u64) + // Standard Error: 838 + .saturating_add(Weight::from_ref_time(533_809 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 624 nanoseconds. - Weight::from_ref_time(170_717 as u64) - // Standard Error: 1_959 - .saturating_add(Weight::from_ref_time(867_748 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(1_055_669 as u64) + // Standard Error: 2_735 + .saturating_add(Weight::from_ref_time(805_830 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 648 nanoseconds. - Weight::from_ref_time(539_108 as u64) - // Standard Error: 1_490 - .saturating_add(Weight::from_ref_time(1_077_401 as u64).saturating_mul(r as u64)) + // Minimum execution time: 687 nanoseconds. + Weight::from_ref_time(543_603 as u64) + // Standard Error: 1_877 + .saturating_add(Weight::from_ref_time(1_083_080 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 2_179 nanoseconds. - Weight::from_ref_time(2_597_080 as u64) - // Standard Error: 74 - .saturating_add(Weight::from_ref_time(4_865 as u64).saturating_mul(e as u64)) + // Minimum execution time: 2_143 nanoseconds. + Weight::from_ref_time(2_592_361 as u64) + // Standard Error: 76 + .saturating_add(Weight::from_ref_time(4_980 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 633 nanoseconds. - Weight::from_ref_time(1_498_082 as u64) - // Standard Error: 1_780 - .saturating_add(Weight::from_ref_time(2_198_342 as u64).saturating_mul(r as u64)) + // Minimum execution time: 662 nanoseconds. + Weight::from_ref_time(1_475_621 as u64) + // Standard Error: 2_062 + .saturating_add(Weight::from_ref_time(2_201_208 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 806 nanoseconds. - Weight::from_ref_time(1_904_912 as u64) - // Standard Error: 1_182 - .saturating_add(Weight::from_ref_time(2_801_959 as u64).saturating_mul(r as u64)) + // Minimum execution time: 814 nanoseconds. + Weight::from_ref_time(1_978_277 as u64) + // Standard Error: 1_626 + .saturating_add(Weight::from_ref_time(2_816_687 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 4_219 nanoseconds. - Weight::from_ref_time(5_152_036 as u64) - // Standard Error: 290 - .saturating_add(Weight::from_ref_time(179_507 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_200 nanoseconds. + Weight::from_ref_time(5_119_408 as u64) + // Standard Error: 482 + .saturating_add(Weight::from_ref_time(179_490 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 1_438 nanoseconds. - Weight::from_ref_time(1_730_599 as u64) - // Standard Error: 208 - .saturating_add(Weight::from_ref_time(364_842 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_622 nanoseconds. + Weight::from_ref_time(1_884_170 as u64) + // Standard Error: 200 + .saturating_add(Weight::from_ref_time(366_730 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 1_430 nanoseconds. - Weight::from_ref_time(1_671_358 as u64) - // Standard Error: 276 - .saturating_add(Weight::from_ref_time(383_715 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_613 nanoseconds. + Weight::from_ref_time(1_852_996 as u64) + // Standard Error: 180 + .saturating_add(Weight::from_ref_time(383_440 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 1_394 nanoseconds. - Weight::from_ref_time(1_708_668 as u64) - // Standard Error: 199 - .saturating_add(Weight::from_ref_time(526_648 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_556 nanoseconds. + Weight::from_ref_time(1_911_516 as u64) + // Standard Error: 257 + .saturating_add(Weight::from_ref_time(528_015 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 713 nanoseconds. - Weight::from_ref_time(1_095_871 as u64) - // Standard Error: 343 - .saturating_add(Weight::from_ref_time(811_365 as u64).saturating_mul(r as u64)) + // Minimum execution time: 722 nanoseconds. + Weight::from_ref_time(1_079_902 as u64) + // Standard Error: 757 + .saturating_add(Weight::from_ref_time(816_335 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 727 nanoseconds. - Weight::from_ref_time(1_056_556 as u64) - // Standard Error: 355 - .saturating_add(Weight::from_ref_time(830_505 as u64).saturating_mul(r as u64)) + // Minimum execution time: 736 nanoseconds. + Weight::from_ref_time(989_270 as u64) + // Standard Error: 384 + .saturating_add(Weight::from_ref_time(831_122 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 753 nanoseconds. - Weight::from_ref_time(1_004_624 as u64) - // Standard Error: 259 - .saturating_add(Weight::from_ref_time(693_886 as u64).saturating_mul(r as u64)) + // Minimum execution time: 773 nanoseconds. + Weight::from_ref_time(1_086_755 as u64) + // Standard Error: 443 + .saturating_add(Weight::from_ref_time(694_504 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 649 nanoseconds. - Weight::from_ref_time(742_979 as u64) - // Standard Error: 5_852 - .saturating_add(Weight::from_ref_time(184_932_720 as u64).saturating_mul(r as u64)) + // Minimum execution time: 739 nanoseconds. + Weight::from_ref_time(812_861 as u64) + // Standard Error: 5_072 + .saturating_add(Weight::from_ref_time(183_573_238 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 615 nanoseconds. - Weight::from_ref_time(919_735 as u64) - // Standard Error: 443 - .saturating_add(Weight::from_ref_time(509_234 as u64).saturating_mul(r as u64)) + // Minimum execution time: 685 nanoseconds. + Weight::from_ref_time(956_397 as u64) + // Standard Error: 343 + .saturating_add(Weight::from_ref_time(509_878 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 623 nanoseconds. - Weight::from_ref_time(883_408 as u64) - // Standard Error: 437 - .saturating_add(Weight::from_ref_time(517_270 as u64).saturating_mul(r as u64)) + // Minimum execution time: 641 nanoseconds. + Weight::from_ref_time(940_299 as u64) + // Standard Error: 309 + .saturating_add(Weight::from_ref_time(513_853 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 613 nanoseconds. - Weight::from_ref_time(819_503 as u64) - // Standard Error: 704 - .saturating_add(Weight::from_ref_time(518_031 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(924_404 as u64) + // Standard Error: 211 + .saturating_add(Weight::from_ref_time(513_663 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 647 nanoseconds. - Weight::from_ref_time(922_130 as u64) - // Standard Error: 384 - .saturating_add(Weight::from_ref_time(525_187 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(1_021_461 as u64) + // Standard Error: 1_878 + .saturating_add(Weight::from_ref_time(525_934 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 592 nanoseconds. - Weight::from_ref_time(930_340 as u64) - // Standard Error: 277 - .saturating_add(Weight::from_ref_time(505_104 as u64).saturating_mul(r as u64)) + // Minimum execution time: 618 nanoseconds. + Weight::from_ref_time(920_038 as u64) + // Standard Error: 269 + .saturating_add(Weight::from_ref_time(507_263 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 661 nanoseconds. - Weight::from_ref_time(942_938 as u64) - // Standard Error: 268 - .saturating_add(Weight::from_ref_time(504_997 as u64).saturating_mul(r as u64)) + // Minimum execution time: 638 nanoseconds. + Weight::from_ref_time(921_016 as u64) + // Standard Error: 208 + .saturating_add(Weight::from_ref_time(507_276 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 613 nanoseconds. - Weight::from_ref_time(864_875 as u64) - // Standard Error: 720 - .saturating_add(Weight::from_ref_time(508_015 as u64).saturating_mul(r as u64)) + // Minimum execution time: 628 nanoseconds. + Weight::from_ref_time(918_282 as u64) + // Standard Error: 267 + .saturating_add(Weight::from_ref_time(506_343 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 609 nanoseconds. - Weight::from_ref_time(964_975 as u64) - // Standard Error: 508 - .saturating_add(Weight::from_ref_time(732_494 as u64).saturating_mul(r as u64)) + // Minimum execution time: 683 nanoseconds. + Weight::from_ref_time(912_847 as u64) + // Standard Error: 216 + .saturating_add(Weight::from_ref_time(733_648 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(991_551 as u64) - // Standard Error: 1_126 - .saturating_add(Weight::from_ref_time(731_593 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(937_179 as u64) + // Standard Error: 195 + .saturating_add(Weight::from_ref_time(734_905 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(938_821 as u64) - // Standard Error: 535 - .saturating_add(Weight::from_ref_time(741_527 as u64).saturating_mul(r as u64)) + // Minimum execution time: 650 nanoseconds. + Weight::from_ref_time(928_242 as u64) + // Standard Error: 197 + .saturating_add(Weight::from_ref_time(741_814 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 634 nanoseconds. - Weight::from_ref_time(969_389 as u64) - // Standard Error: 421 - .saturating_add(Weight::from_ref_time(743_647 as u64).saturating_mul(r as u64)) + // Minimum execution time: 666 nanoseconds. + Weight::from_ref_time(978_908 as u64) + // Standard Error: 212 + .saturating_add(Weight::from_ref_time(743_646 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 620 nanoseconds. - Weight::from_ref_time(997_361 as u64) - // Standard Error: 540 - .saturating_add(Weight::from_ref_time(748_108 as u64).saturating_mul(r as u64)) + // Minimum execution time: 685 nanoseconds. + Weight::from_ref_time(954_961 as u64) + // Standard Error: 215 + .saturating_add(Weight::from_ref_time(747_737 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 586 nanoseconds. - Weight::from_ref_time(966_929 as u64) - // Standard Error: 524 - .saturating_add(Weight::from_ref_time(760_077 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(911_765 as u64) + // Standard Error: 251 + .saturating_add(Weight::from_ref_time(747_195 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 623 nanoseconds. - Weight::from_ref_time(974_811 as u64) - // Standard Error: 528 - .saturating_add(Weight::from_ref_time(745_124 as u64).saturating_mul(r as u64)) + // Minimum execution time: 632 nanoseconds. + Weight::from_ref_time(950_928 as u64) + // Standard Error: 287 + .saturating_add(Weight::from_ref_time(735_938 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(990_326 as u64) - // Standard Error: 535 - .saturating_add(Weight::from_ref_time(808_599 as u64).saturating_mul(r as u64)) + // Minimum execution time: 614 nanoseconds. + Weight::from_ref_time(885_567 as u64) + // Standard Error: 2_216 + .saturating_add(Weight::from_ref_time(747_731 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 600 nanoseconds. - Weight::from_ref_time(969_957 as u64) - // Standard Error: 604 - .saturating_add(Weight::from_ref_time(744_174 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(929_711 as u64) + // Standard Error: 180 + .saturating_add(Weight::from_ref_time(736_449 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 632 nanoseconds. - Weight::from_ref_time(976_250 as u64) - // Standard Error: 938 - .saturating_add(Weight::from_ref_time(798_224 as u64).saturating_mul(r as u64)) + // Minimum execution time: 655 nanoseconds. + Weight::from_ref_time(918_994 as u64) + // Standard Error: 673 + .saturating_add(Weight::from_ref_time(742_317 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 627 nanoseconds. - Weight::from_ref_time(939_131 as u64) - // Standard Error: 457 - .saturating_add(Weight::from_ref_time(718_514 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(925_471 as u64) + // Standard Error: 207 + .saturating_add(Weight::from_ref_time(720_264 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 621 nanoseconds. - Weight::from_ref_time(905_432 as u64) - // Standard Error: 637 - .saturating_add(Weight::from_ref_time(716_365 as u64).saturating_mul(r as u64)) + // Minimum execution time: 630 nanoseconds. + Weight::from_ref_time(915_027 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(715_446 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 610 nanoseconds. - Weight::from_ref_time(926_074 as u64) - // Standard Error: 457 - .saturating_add(Weight::from_ref_time(716_003 as u64).saturating_mul(r as u64)) + // Minimum execution time: 658 nanoseconds. + Weight::from_ref_time(944_559 as u64) + // Standard Error: 190 + .saturating_add(Weight::from_ref_time(715_915 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 595 nanoseconds. - Weight::from_ref_time(1_023_054 as u64) - // Standard Error: 2_584 - .saturating_add(Weight::from_ref_time(1_349_736 as u64).saturating_mul(r as u64)) + // Minimum execution time: 622 nanoseconds. + Weight::from_ref_time(917_324 as u64) + // Standard Error: 447 + .saturating_add(Weight::from_ref_time(1_355_730 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 608 nanoseconds. - Weight::from_ref_time(966_937 as u64) - // Standard Error: 786 - .saturating_add(Weight::from_ref_time(1_284_291 as u64).saturating_mul(r as u64)) + // Minimum execution time: 643 nanoseconds. + Weight::from_ref_time(899_983 as u64) + // Standard Error: 430 + .saturating_add(Weight::from_ref_time(1_285_187 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(972_082 as u64) - // Standard Error: 1_441 - .saturating_add(Weight::from_ref_time(1_403_148 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(896_030 as u64) + // Standard Error: 528 + .saturating_add(Weight::from_ref_time(1_401_764 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 644 nanoseconds. - Weight::from_ref_time(991_706 as u64) - // Standard Error: 1_103 - .saturating_add(Weight::from_ref_time(1_284_545 as u64).saturating_mul(r as u64)) + // Minimum execution time: 609 nanoseconds. + Weight::from_ref_time(859_662 as u64) + // Standard Error: 730 + .saturating_add(Weight::from_ref_time(1_287_681 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 630 nanoseconds. - Weight::from_ref_time(941_587 as u64) - // Standard Error: 506 - .saturating_add(Weight::from_ref_time(719_943 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(902_285 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(721_017 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 624 nanoseconds. - Weight::from_ref_time(939_991 as u64) - // Standard Error: 520 - .saturating_add(Weight::from_ref_time(719_994 as u64).saturating_mul(r as u64)) + // Minimum execution time: 682 nanoseconds. + Weight::from_ref_time(957_929 as u64) + // Standard Error: 235 + .saturating_add(Weight::from_ref_time(718_864 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 609 nanoseconds. - Weight::from_ref_time(970_308 as u64) - // Standard Error: 552 - .saturating_add(Weight::from_ref_time(719_566 as u64).saturating_mul(r as u64)) + // Minimum execution time: 637 nanoseconds. + Weight::from_ref_time(793_291 as u64) + // Standard Error: 601 + .saturating_add(Weight::from_ref_time(727_384 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 613 nanoseconds. - Weight::from_ref_time(920_835 as u64) - // Standard Error: 623 - .saturating_add(Weight::from_ref_time(737_690 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(974_702 as u64) + // Standard Error: 350 + .saturating_add(Weight::from_ref_time(736_068 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 626 nanoseconds. - Weight::from_ref_time(919_030 as u64) - // Standard Error: 486 - .saturating_add(Weight::from_ref_time(737_096 as u64).saturating_mul(r as u64)) + // Minimum execution time: 636 nanoseconds. + Weight::from_ref_time(900_404 as u64) + // Standard Error: 355 + .saturating_add(Weight::from_ref_time(738_519 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 634 nanoseconds. - Weight::from_ref_time(964_779 as u64) - // Standard Error: 496 - .saturating_add(Weight::from_ref_time(736_322 as u64).saturating_mul(r as u64)) + // Minimum execution time: 646 nanoseconds. + Weight::from_ref_time(1_000_078 as u64) + // Standard Error: 340 + .saturating_add(Weight::from_ref_time(735_680 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 631 nanoseconds. - Weight::from_ref_time(918_768 as u64) - // Standard Error: 952 - .saturating_add(Weight::from_ref_time(740_280 as u64).saturating_mul(r as u64)) + // Minimum execution time: 621 nanoseconds. + Weight::from_ref_time(933_845 as u64) + // Standard Error: 194 + .saturating_add(Weight::from_ref_time(736_788 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 639 nanoseconds. - Weight::from_ref_time(955_994 as u64) - // Standard Error: 523 - .saturating_add(Weight::from_ref_time(738_232 as u64).saturating_mul(r as u64)) + // Minimum execution time: 640 nanoseconds. + Weight::from_ref_time(932_522 as u64) + // Standard Error: 262 + .saturating_add(Weight::from_ref_time(736_535 as u64).saturating_mul(r as u64)) } } From 8df8b7062e58b30731a146dad57569275ba00d40 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Fri, 18 Nov 2022 09:34:26 +0100 Subject: [PATCH 20/27] Fix benchmark merge fail --- frame/contracts/src/benchmarking/mod.rs | 6 +++--- frame/contracts/src/weights.rs | 21 +++++++++++++++++++++ 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/frame/contracts/src/benchmarking/mod.rs b/frame/contracts/src/benchmarking/mod.rs index bce2b4ae5e78c..2494a4cbebd55 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -2045,7 +2045,7 @@ benchmarks! { let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) - seal_reentrance_count { + seal_set_code_hash { let r in 0 .. API_BENCHMARK_BATCHES; let code_hashes = (0..r * API_BENCHMARK_BATCH_SIZE) .map(|i| { @@ -2085,7 +2085,7 @@ benchmarks! { let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) - seal_account_reentrance_count { + seal_reentrance_count { let r in 0 .. API_BENCHMARK_BATCHES; let code = WasmModule::::from(ModuleDefinition { memory: Some(ImportedMemory::max::()), @@ -2105,7 +2105,7 @@ benchmarks! { let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) - account_reentrance_count { + seal_account_reentrance_count { let r in 0 .. API_BENCHMARK_BATCHES; let dummy_code = WasmModule::::dummy_with_bytes(0); let accounts = (0..r * API_BENCHMARK_BATCH_SIZE) diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index 5c097f616885f..d972b101829e1 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -109,6 +109,7 @@ pub trait WeightInfo { fn seal_hash_blake2_128_per_kb(n: 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 seal_reentrance_count(r: u32, ) -> Weight; fn seal_account_reentrance_count(r: u32, ) -> Weight; fn account_reentrance_count(r: u32, ) -> Weight; @@ -1006,6 +1007,16 @@ impl WeightInfo for SubstrateWeight { .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } + fn seal_set_code_hash(r: u32, ) -> Weight { + // Minimum execution time: 293_390 nanoseconds. + Weight::from_ref_time(297_791_000 as u64) + // Standard Error: 2_704_135 + .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) + .saturating_add(T::DbWeight::get().writes(3 as u64)) + .saturating_add(T::DbWeight::get().writes((150 as u64).saturating_mul(r as u64))) + } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) @@ -2250,6 +2261,16 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } + fn seal_set_code_hash(r: u32, ) -> Weight { + // Minimum execution time: 293_390 nanoseconds. + Weight::from_ref_time(297_791_000 as u64) + // Standard Error: 2_704_135 + .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) + .saturating_add(RocksDbWeight::get().reads(6 as u64)) + .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) + .saturating_add(RocksDbWeight::get().writes(3 as u64)) + .saturating_add(RocksDbWeight::get().writes((150 as u64).saturating_mul(r as u64))) + } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) From fee21daab69bc24b5e679d5ee02cc160eca8f12c Mon Sep 17 00:00:00 2001 From: command-bot <> Date: Fri, 18 Nov 2022 12:06:15 +0000 Subject: [PATCH 21/27] ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts --- frame/contracts/src/weights.rs | 1859 ++++++++++++++++---------------- 1 file changed, 919 insertions(+), 940 deletions(-) diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index d972b101829e1..f5c12e92ca94e 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -18,7 +18,7 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-11-17, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-11-18, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 @@ -112,7 +112,6 @@ pub trait WeightInfo { fn seal_set_code_hash(r: u32, ) -> Weight; fn seal_reentrance_count(r: u32, ) -> Weight; fn seal_account_reentrance_count(r: u32, ) -> Weight; - fn account_reentrance_count(r: u32, ) -> Weight; fn instr_i64const(r: u32, ) -> Weight; fn instr_i64load(r: u32, ) -> Weight; fn instr_i64store(r: u32, ) -> Weight; @@ -171,17 +170,17 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 3_254 nanoseconds. - Weight::from_ref_time(3_367_000 as u64) + // Minimum execution time: 3_174 nanoseconds. + Weight::from_ref_time(3_298_000 as u64) .saturating_add(T::DbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 16_206 nanoseconds. - Weight::from_ref_time(19_434_064 as u64) - // Standard Error: 715 - .saturating_add(Weight::from_ref_time(963_296 as u64).saturating_mul(k as u64)) + // Minimum execution time: 15_218 nanoseconds. + Weight::from_ref_time(15_548_154 as u64) + // Standard Error: 732 + .saturating_add(Weight::from_ref_time(940_242 as u64).saturating_mul(k as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -189,10 +188,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 3_130 nanoseconds. - Weight::from_ref_time(18_640_668 as u64) - // Standard Error: 4_357 - .saturating_add(Weight::from_ref_time(1_274_044 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_096 nanoseconds. + Weight::from_ref_time(14_949_039 as u64) + // Standard Error: 3_466 + .saturating_add(Weight::from_ref_time(1_236_160 as u64).saturating_mul(q as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -200,10 +199,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 29_419 nanoseconds. - Weight::from_ref_time(20_616_893 as u64) - // Standard Error: 44 - .saturating_add(Weight::from_ref_time(47_249 as u64).saturating_mul(c as u64)) + // Minimum execution time: 28_333 nanoseconds. + Weight::from_ref_time(19_421_544 as u64) + // Standard Error: 92 + .saturating_add(Weight::from_ref_time(47_629 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } @@ -214,10 +213,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 311_735 nanoseconds. - Weight::from_ref_time(324_179_000 as u64) - // Standard Error: 23 - .saturating_add(Weight::from_ref_time(31_787 as u64).saturating_mul(c as u64)) + // Minimum execution time: 304_381 nanoseconds. + Weight::from_ref_time(315_177_233 as u64) + // Standard Error: 22 + .saturating_add(Weight::from_ref_time(30_372 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -232,12 +231,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_187_833 nanoseconds. - Weight::from_ref_time(419_021_666 as u64) - // Standard Error: 64 - .saturating_add(Weight::from_ref_time(91_150 as u64).saturating_mul(c as u64)) - // Standard Error: 3 - .saturating_add(Weight::from_ref_time(1_767 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_119_963 nanoseconds. + Weight::from_ref_time(337_976_516 as u64) + // Standard Error: 84 + .saturating_add(Weight::from_ref_time(88_566 as u64).saturating_mul(c as u64)) + // Standard Error: 5 + .saturating_add(Weight::from_ref_time(1_747 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(9 as u64)) } @@ -250,10 +249,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 193_073 nanoseconds. - Weight::from_ref_time(177_294_408 as u64) + // Minimum execution time: 184_739 nanoseconds. + Weight::from_ref_time(179_778_057 as u64) // Standard Error: 2 - .saturating_add(Weight::from_ref_time(1_563 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_487 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().writes(7 as u64)) } @@ -263,8 +262,8 @@ impl WeightInfo for SubstrateWeight { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 160_898 nanoseconds. - Weight::from_ref_time(161_990_000 as u64) + // Minimum execution time: 154_711 nanoseconds. + Weight::from_ref_time(155_527_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -274,10 +273,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 305_859 nanoseconds. - Weight::from_ref_time(309_986_743 as u64) - // Standard Error: 65 - .saturating_add(Weight::from_ref_time(91_731 as u64).saturating_mul(c as u64)) + // Minimum execution time: 294_982 nanoseconds. + Weight::from_ref_time(302_482_450 as u64) + // Standard Error: 62 + .saturating_add(Weight::from_ref_time(88_358 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -286,8 +285,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 41_544 nanoseconds. - Weight::from_ref_time(41_956_000 as u64) + // Minimum execution time: 39_655 nanoseconds. + Weight::from_ref_time(40_147_000 as u64) .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(4 as u64)) } @@ -295,8 +294,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 43_313 nanoseconds. - Weight::from_ref_time(43_987_000 as u64) + // Minimum execution time: 41_028 nanoseconds. + Weight::from_ref_time(41_565_000 as u64) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(6 as u64)) } @@ -307,10 +306,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 300_251 nanoseconds. - Weight::from_ref_time(308_118_154 as u64) - // Standard Error: 13_919 - .saturating_add(Weight::from_ref_time(16_555_470 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_231 nanoseconds. + Weight::from_ref_time(298_245_008 as u64) + // Standard Error: 41_817 + .saturating_add(Weight::from_ref_time(16_183_097 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -321,10 +320,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 302_090 nanoseconds. - Weight::from_ref_time(237_951_992 as u64) - // Standard Error: 425_584 - .saturating_add(Weight::from_ref_time(213_514_628 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_152 nanoseconds. + Weight::from_ref_time(231_239_439 as u64) + // Standard Error: 475_771 + .saturating_add(Weight::from_ref_time(193_804_587 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -336,10 +335,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 303_203 nanoseconds. - Weight::from_ref_time(263_005_297 as u64) - // Standard Error: 376_919 - .saturating_add(Weight::from_ref_time(265_396_805 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_171 nanoseconds. + Weight::from_ref_time(244_339_298 as u64) + // Standard Error: 440_060 + .saturating_add(Weight::from_ref_time(236_224_857 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -351,10 +350,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 304_113 nanoseconds. - Weight::from_ref_time(311_754_829 as u64) - // Standard Error: 18_343 - .saturating_add(Weight::from_ref_time(19_940_285 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_891 nanoseconds. + Weight::from_ref_time(298_061_159 as u64) + // Standard Error: 30_013 + .saturating_add(Weight::from_ref_time(19_682_309 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -365,10 +364,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 301_259 nanoseconds. - Weight::from_ref_time(308_994_291 as u64) - // Standard Error: 14_116 - .saturating_add(Weight::from_ref_time(11_176_417 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_259 nanoseconds. + Weight::from_ref_time(296_675_355 as u64) + // Standard Error: 24_508 + .saturating_add(Weight::from_ref_time(10_949_451 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -379,10 +378,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 301_414 nanoseconds. - Weight::from_ref_time(310_130_007 as u64) - // Standard Error: 21_977 - .saturating_add(Weight::from_ref_time(16_288_617 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_507 nanoseconds. + Weight::from_ref_time(295_682_709 as u64) + // Standard Error: 43_685 + .saturating_add(Weight::from_ref_time(16_461_873 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -393,10 +392,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 300_342 nanoseconds. - Weight::from_ref_time(308_941_812 as u64) - // Standard Error: 15_417 - .saturating_add(Weight::from_ref_time(16_046_689 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_473 nanoseconds. + Weight::from_ref_time(296_523_274 as u64) + // Standard Error: 34_356 + .saturating_add(Weight::from_ref_time(15_932_835 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -407,10 +406,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 300_133 nanoseconds. - Weight::from_ref_time(311_277_478 as u64) - // Standard Error: 35_954 - .saturating_add(Weight::from_ref_time(97_275_936 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_889 nanoseconds. + Weight::from_ref_time(295_471_068 as u64) + // Standard Error: 88_937 + .saturating_add(Weight::from_ref_time(89_606_655 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -421,10 +420,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 299_980 nanoseconds. - Weight::from_ref_time(308_487_901 as u64) - // Standard Error: 15_791 - .saturating_add(Weight::from_ref_time(15_971_242 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_747 nanoseconds. + Weight::from_ref_time(297_023_967 as u64) + // Standard Error: 18_756 + .saturating_add(Weight::from_ref_time(15_748_008 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -435,10 +434,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 300_042 nanoseconds. - Weight::from_ref_time(308_378_169 as u64) - // Standard Error: 13_644 - .saturating_add(Weight::from_ref_time(15_940_362 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_590 nanoseconds. + Weight::from_ref_time(296_257_202 as u64) + // Standard Error: 24_863 + .saturating_add(Weight::from_ref_time(15_851_537 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -449,10 +448,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 299_913 nanoseconds. - Weight::from_ref_time(306_528_553 as u64) - // Standard Error: 18_702 - .saturating_add(Weight::from_ref_time(16_259_237 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_746 nanoseconds. + Weight::from_ref_time(297_308_097 as u64) + // Standard Error: 29_585 + .saturating_add(Weight::from_ref_time(15_608_985 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -463,10 +462,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 300_639 nanoseconds. - Weight::from_ref_time(310_298_448 as u64) - // Standard Error: 20_201 - .saturating_add(Weight::from_ref_time(15_923_667 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_662 nanoseconds. + Weight::from_ref_time(296_393_072 as u64) + // Standard Error: 23_750 + .saturating_add(Weight::from_ref_time(15_891_911 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -478,10 +477,10 @@ impl WeightInfo for SubstrateWeight { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 300_200 nanoseconds. - Weight::from_ref_time(312_744_329 as u64) - // Standard Error: 33_748 - .saturating_add(Weight::from_ref_time(88_361_056 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_036 nanoseconds. + Weight::from_ref_time(301_071_620 as u64) + // Standard Error: 85_146 + .saturating_add(Weight::from_ref_time(84_455_768 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -492,10 +491,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 148_130 nanoseconds. - Weight::from_ref_time(151_542_553 as u64) - // Standard Error: 9_571 - .saturating_add(Weight::from_ref_time(8_134_705 as u64).saturating_mul(r as u64)) + // Minimum execution time: 142_655 nanoseconds. + Weight::from_ref_time(145_691_226 as u64) + // Standard Error: 11_085 + .saturating_add(Weight::from_ref_time(7_953_680 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -506,10 +505,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 299_987 nanoseconds. - Weight::from_ref_time(307_696_695 as u64) - // Standard Error: 15_723 - .saturating_add(Weight::from_ref_time(14_189_895 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_613 nanoseconds. + Weight::from_ref_time(296_889_714 as u64) + // Standard Error: 21_550 + .saturating_add(Weight::from_ref_time(13_672_097 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -520,10 +519,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 318_276 nanoseconds. - Weight::from_ref_time(335_793_925 as u64) - // Standard Error: 1_344 - .saturating_add(Weight::from_ref_time(9_778_604 as u64).saturating_mul(n as u64)) + // Minimum execution time: 309_866 nanoseconds. + Weight::from_ref_time(328_331_386 as u64) + // Standard Error: 6_205 + .saturating_add(Weight::from_ref_time(9_619_067 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -534,10 +533,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 296_050 nanoseconds. - Weight::from_ref_time(303_863_300 as u64) - // Standard Error: 227_870 - .saturating_add(Weight::from_ref_time(235_100 as u64).saturating_mul(r as u64)) + // Minimum execution time: 288_265 nanoseconds. + Weight::from_ref_time(292_739_779 as u64) + // Standard Error: 108_313 + .saturating_add(Weight::from_ref_time(1_475_820 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -548,10 +547,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 299_553 nanoseconds. - Weight::from_ref_time(304_972_388 as u64) - // Standard Error: 262 - .saturating_add(Weight::from_ref_time(197_295 as u64).saturating_mul(n as u64)) + // Minimum execution time: 293_044 nanoseconds. + Weight::from_ref_time(293_846_263 as u64) + // Standard Error: 641 + .saturating_add(Weight::from_ref_time(188_770 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -564,10 +563,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 299_708 nanoseconds. - Weight::from_ref_time(306_055_389 as u64) - // Standard Error: 198_678 - .saturating_add(Weight::from_ref_time(57_427_210 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_248 nanoseconds. + Weight::from_ref_time(294_406_912 as u64) + // Standard Error: 112_528 + .saturating_add(Weight::from_ref_time(52_650_987 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -581,10 +580,10 @@ impl WeightInfo for SubstrateWeight { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 297_866 nanoseconds. - Weight::from_ref_time(311_103_336 as u64) - // Standard Error: 38_424 - .saturating_add(Weight::from_ref_time(112_211_212 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_980 nanoseconds. + Weight::from_ref_time(298_232_040 as u64) + // Standard Error: 85_517 + .saturating_add(Weight::from_ref_time(108_891_823 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -595,10 +594,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 297_574 nanoseconds. - Weight::from_ref_time(311_916_564 as u64) - // Standard Error: 62_376 - .saturating_add(Weight::from_ref_time(224_881_274 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_668 nanoseconds. + Weight::from_ref_time(302_010_570 as u64) + // Standard Error: 109_901 + .saturating_add(Weight::from_ref_time(214_667_762 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -610,12 +609,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_234_995 nanoseconds. - Weight::from_ref_time(510_845_948 as u64) - // Standard Error: 447_066 - .saturating_add(Weight::from_ref_time(188_646_130 as u64).saturating_mul(t as u64)) - // Standard Error: 122_786 - .saturating_add(Weight::from_ref_time(72_057_262 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_163_533 nanoseconds. + Weight::from_ref_time(501_280_410 as u64) + // Standard Error: 601_576 + .saturating_add(Weight::from_ref_time(172_210_846 as u64).saturating_mul(t as u64)) + // Standard Error: 165_221 + .saturating_add(Weight::from_ref_time(67_584_003 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -628,20 +627,20 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 161_631 nanoseconds. - Weight::from_ref_time(164_876_481 as u64) - // Standard Error: 13_873 - .saturating_add(Weight::from_ref_time(13_009_186 as u64).saturating_mul(r as u64)) + // Minimum execution time: 154_390 nanoseconds. + Weight::from_ref_time(158_246_775 as u64) + // Standard Error: 23_812 + .saturating_add(Weight::from_ref_time(12_810_293 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 301_039 nanoseconds. - Weight::from_ref_time(251_149_124 as u64) - // Standard Error: 549_293 - .saturating_add(Weight::from_ref_time(445_621_099 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_926 nanoseconds. + Weight::from_ref_time(250_238_246 as u64) + // Standard Error: 485_292 + .saturating_add(Weight::from_ref_time(402_779_709 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -650,10 +649,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 435_530 nanoseconds. - Weight::from_ref_time(614_238_840 as u64) - // Standard Error: 1_623_692 - .saturating_add(Weight::from_ref_time(101_595_333 as u64).saturating_mul(n as u64)) + // Minimum execution time: 421_504 nanoseconds. + Weight::from_ref_time(574_267_945 as u64) + // Standard Error: 1_407_019 + .saturating_add(Weight::from_ref_time(89_516_682 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(52 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(50 as u64)) @@ -662,10 +661,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 436_827 nanoseconds. - Weight::from_ref_time(594_521_125 as u64) - // Standard Error: 1_460_598 - .saturating_add(Weight::from_ref_time(68_080_949 as u64).saturating_mul(n as u64)) + // Minimum execution time: 421_422 nanoseconds. + Weight::from_ref_time(545_948_271 as u64) + // Standard Error: 1_148_143 + .saturating_add(Weight::from_ref_time(63_958_096 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(49 as u64)) @@ -674,10 +673,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 300_911 nanoseconds. - Weight::from_ref_time(252_994_248 as u64) - // Standard Error: 538_853 - .saturating_add(Weight::from_ref_time(438_726_157 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_545 nanoseconds. + Weight::from_ref_time(255_622_312 as u64) + // Standard Error: 407_862 + .saturating_add(Weight::from_ref_time(396_764_962 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -686,10 +685,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 403_401 nanoseconds. - Weight::from_ref_time(577_182_970 as u64) - // Standard Error: 1_589_458 - .saturating_add(Weight::from_ref_time(69_873_104 as u64).saturating_mul(n as u64)) + // Minimum execution time: 390_339 nanoseconds. + Weight::from_ref_time(528_774_888 as u64) + // Standard Error: 1_278_188 + .saturating_add(Weight::from_ref_time(66_683_698 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -698,10 +697,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 302_119 nanoseconds. - Weight::from_ref_time(265_001_135 as u64) - // Standard Error: 456_550 - .saturating_add(Weight::from_ref_time(358_664_775 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_904 nanoseconds. + Weight::from_ref_time(265_679_354 as u64) + // Standard Error: 386_673 + .saturating_add(Weight::from_ref_time(318_869_116 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -709,10 +708,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 385_096 nanoseconds. - Weight::from_ref_time(537_450_417 as u64) - // Standard Error: 1_425_876 - .saturating_add(Weight::from_ref_time(155_746_820 as u64).saturating_mul(n as u64)) + // Minimum execution time: 372_784 nanoseconds. + Weight::from_ref_time(487_784_160 as u64) + // Standard Error: 1_092_850 + .saturating_add(Weight::from_ref_time(152_413_290 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -720,10 +719,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 301_421 nanoseconds. - Weight::from_ref_time(262_762_745 as u64) - // Standard Error: 497_962 - .saturating_add(Weight::from_ref_time(341_682_818 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_191 nanoseconds. + Weight::from_ref_time(270_493_545 as u64) + // Standard Error: 373_565 + .saturating_add(Weight::from_ref_time(302_870_977 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -731,10 +730,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 379_167 nanoseconds. - Weight::from_ref_time(514_239_503 as u64) - // Standard Error: 1_257_747 - .saturating_add(Weight::from_ref_time(64_734_189 as u64).saturating_mul(n as u64)) + // Minimum execution time: 368_641 nanoseconds. + Weight::from_ref_time(469_340_170 as u64) + // Standard Error: 966_589 + .saturating_add(Weight::from_ref_time(62_000_083 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -742,10 +741,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 300_365 nanoseconds. - Weight::from_ref_time(256_283_472 as u64) - // Standard Error: 517_040 - .saturating_add(Weight::from_ref_time(455_679_763 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_717 nanoseconds. + Weight::from_ref_time(254_308_806 as u64) + // Standard Error: 443_802 + .saturating_add(Weight::from_ref_time(408_899_238 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -754,10 +753,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 406_491 nanoseconds. - Weight::from_ref_time(593_727_170 as u64) - // Standard Error: 1_715_624 - .saturating_add(Weight::from_ref_time(163_630_716 as u64).saturating_mul(n as u64)) + // Minimum execution time: 396_211 nanoseconds. + Weight::from_ref_time(545_169_999 as u64) + // Standard Error: 1_390_049 + .saturating_add(Weight::from_ref_time(156_931_202 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(51 as u64)) .saturating_add(T::DbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(T::DbWeight::get().writes(48 as u64)) @@ -770,10 +769,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 302_533 nanoseconds. - Weight::from_ref_time(266_693_382 as u64) - // Standard Error: 510_705 - .saturating_add(Weight::from_ref_time(1_380_402_053 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_145 nanoseconds. + Weight::from_ref_time(241_332_033 as u64) + // Standard Error: 658_837 + .saturating_add(Weight::from_ref_time(1_315_958_335 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(4 as u64)) @@ -786,10 +785,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 303_609 nanoseconds. - Weight::from_ref_time(605_684_212 as u64) - // Standard Error: 9_562_866 - .saturating_add(Weight::from_ref_time(20_814_449_121 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_624 nanoseconds. + Weight::from_ref_time(296_567_000 as u64) + // Standard Error: 6_725_484 + .saturating_add(Weight::from_ref_time(20_773_662_959 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(7 as u64)) .saturating_add(T::DbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -802,10 +801,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 295_036 nanoseconds. - Weight::from_ref_time(299_300_000 as u64) - // Standard Error: 6_617_504 - .saturating_add(Weight::from_ref_time(20_495_640_402 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_698 nanoseconds. + Weight::from_ref_time(297_541_000 as u64) + // Standard Error: 18_681_855 + .saturating_add(Weight::from_ref_time(20_702_951_248 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -819,12 +818,12 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 9_539_055 nanoseconds. - Weight::from_ref_time(8_483_664_501 as u64) - // Standard Error: 7_679_615 - .saturating_add(Weight::from_ref_time(1_308_202_444 as u64).saturating_mul(t as u64)) - // Standard Error: 11_515 - .saturating_add(Weight::from_ref_time(9_772_393 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_491_225 nanoseconds. + Weight::from_ref_time(8_726_446_640 as u64) + // Standard Error: 11_723_053 + .saturating_add(Weight::from_ref_time(1_107_970_775 as u64).saturating_mul(t as u64)) + // Standard Error: 17_578 + .saturating_add(Weight::from_ref_time(9_748_009 as u64).saturating_mul(c as u64)) .saturating_add(T::DbWeight::get().reads(167 as u64)) .saturating_add(T::DbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(163 as u64)) @@ -839,10 +838,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 295_735 nanoseconds. - Weight::from_ref_time(297_194_000 as u64) - // Standard Error: 19_981_805 - .saturating_add(Weight::from_ref_time(26_085_707_987 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_351 nanoseconds. + Weight::from_ref_time(297_837_000 as u64) + // Standard Error: 17_115_732 + .saturating_add(Weight::from_ref_time(25_936_348_025 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(8 as u64)) .saturating_add(T::DbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(5 as u64)) @@ -858,10 +857,10 @@ impl WeightInfo for SubstrateWeight { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 11_604_541 nanoseconds. - Weight::from_ref_time(11_654_911_938 as u64) - // Standard Error: 70_387 - .saturating_add(Weight::from_ref_time(122_480_891 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_367_191 nanoseconds. + Weight::from_ref_time(11_186_726_411 as u64) + // Standard Error: 75_273 + .saturating_add(Weight::from_ref_time(122_421_705 as u64).saturating_mul(s as u64)) .saturating_add(T::DbWeight::get().reads(249 as u64)) .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(T::DbWeight::get().writes(247 as u64)) @@ -874,10 +873,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 291_842 nanoseconds. - Weight::from_ref_time(298_528_736 as u64) - // Standard Error: 221_776 - .saturating_add(Weight::from_ref_time(41_330_763 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_753 nanoseconds. + Weight::from_ref_time(295_491_471 as u64) + // Standard Error: 112_217 + .saturating_add(Weight::from_ref_time(41_976_228 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -888,10 +887,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 335_273 nanoseconds. - Weight::from_ref_time(339_286_000 as u64) - // Standard Error: 60_137 - .saturating_add(Weight::from_ref_time(323_505_025 as u64).saturating_mul(n as u64)) + // Minimum execution time: 335_784 nanoseconds. + Weight::from_ref_time(336_406_000 as u64) + // Standard Error: 58_205 + .saturating_add(Weight::from_ref_time(323_644_833 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -902,10 +901,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 290_208 nanoseconds. - Weight::from_ref_time(297_912_167 as u64) - // Standard Error: 145_143 - .saturating_add(Weight::from_ref_time(52_787_732 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_772 nanoseconds. + Weight::from_ref_time(294_845_565 as u64) + // Standard Error: 118_932 + .saturating_add(Weight::from_ref_time(53_186_034 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -916,10 +915,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 345_905 nanoseconds. - Weight::from_ref_time(350_585_000 as u64) - // Standard Error: 58_069 - .saturating_add(Weight::from_ref_time(247_905_263 as u64).saturating_mul(n as u64)) + // Minimum execution time: 348_057 nanoseconds. + Weight::from_ref_time(354_903_000 as u64) + // Standard Error: 63_036 + .saturating_add(Weight::from_ref_time(247_852_636 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -930,10 +929,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 290_053 nanoseconds. - Weight::from_ref_time(297_967_508 as u64) - // Standard Error: 130_197 - .saturating_add(Weight::from_ref_time(32_326_891 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_417 nanoseconds. + Weight::from_ref_time(295_285_706 as u64) + // Standard Error: 124_630 + .saturating_add(Weight::from_ref_time(31_293_293 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -944,10 +943,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 324_904 nanoseconds. - Weight::from_ref_time(329_481_000 as u64) - // Standard Error: 51_824 - .saturating_add(Weight::from_ref_time(99_701_756 as u64).saturating_mul(n as u64)) + // Minimum execution time: 325_903 nanoseconds. + Weight::from_ref_time(326_482_000 as u64) + // Standard Error: 47_465 + .saturating_add(Weight::from_ref_time(99_615_769 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -958,10 +957,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 287_563 nanoseconds. - Weight::from_ref_time(296_961_751 as u64) - // Standard Error: 234_387 - .saturating_add(Weight::from_ref_time(30_922_648 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_624 nanoseconds. + Weight::from_ref_time(295_781_938 as u64) + // Standard Error: 849_772 + .saturating_add(Weight::from_ref_time(30_869_061 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -972,10 +971,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 323_485 nanoseconds. - Weight::from_ref_time(328_169_000 as u64) - // Standard Error: 49_606 - .saturating_add(Weight::from_ref_time(99_726_280 as u64).saturating_mul(n as u64)) + // Minimum execution time: 323_456 nanoseconds. + Weight::from_ref_time(324_815_000 as u64) + // Standard Error: 49_126 + .saturating_add(Weight::from_ref_time(99_651_878 as u64).saturating_mul(n as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -986,10 +985,10 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 289_611 nanoseconds. - Weight::from_ref_time(299_478_153 as u64) - // Standard Error: 466_179 - .saturating_add(Weight::from_ref_time(3_032_914_046 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_244 nanoseconds. + Weight::from_ref_time(296_117_277 as u64) + // Standard Error: 513_100 + .saturating_add(Weight::from_ref_time(3_005_168_422 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1000,23 +999,13 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 292_544 nanoseconds. - Weight::from_ref_time(299_101_359 as u64) - // Standard Error: 435_234 - .saturating_add(Weight::from_ref_time(2_043_545_340 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_099 nanoseconds. + Weight::from_ref_time(295_349_591 as u64) + // Standard Error: 437_688 + .saturating_add(Weight::from_ref_time(2_079_472_608 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } - fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 293_390 nanoseconds. - Weight::from_ref_time(297_791_000 as u64) - // Standard Error: 2_704_135 - .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) - .saturating_add(T::DbWeight::get().reads(6 as u64)) - .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) - .saturating_add(T::DbWeight::get().writes(3 as u64)) - .saturating_add(T::DbWeight::get().writes((150 as u64).saturating_mul(r as u64))) - } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) @@ -1024,11 +1013,11 @@ impl WeightInfo for SubstrateWeight { // Storage: System EventTopics (r:2 w:2) // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. - fn seal_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 293_390 nanoseconds. - Weight::from_ref_time(297_791_000 as u64) - // Standard Error: 2_704_135 - .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) + fn seal_set_code_hash(r: u32, ) -> Weight { + // Minimum execution time: 293_692 nanoseconds. + Weight::from_ref_time(294_871_000 as u64) + // Standard Error: 2_737_018 + .saturating_add(Weight::from_ref_time(1_360_098_499 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(T::DbWeight::get().writes(3 as u64)) @@ -1040,11 +1029,11 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 294_837 nanoseconds. - Weight::from_ref_time(304_337_243 as u64) - // Standard Error: 43_642 - .saturating_add(Weight::from_ref_time(10_830_982 as u64).saturating_mul(r as u64)) + fn seal_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 295_570 nanoseconds. + Weight::from_ref_time(299_077_520 as u64) + // Standard Error: 23_516 + .saturating_add(Weight::from_ref_time(10_971_589 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } @@ -1054,370 +1043,370 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn account_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 294_852 nanoseconds. - Weight::from_ref_time(343_714_525 as u64) - // Standard Error: 140_657 - .saturating_add(Weight::from_ref_time(24_444_391 as u64).saturating_mul(r as u64)) + fn seal_account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 296_873 nanoseconds. + Weight::from_ref_time(336_309_706 as u64) + // Standard Error: 125_484 + .saturating_add(Weight::from_ref_time(25_321_948 as u64).saturating_mul(r as u64)) .saturating_add(T::DbWeight::get().reads(6 as u64)) .saturating_add(T::DbWeight::get().writes(3 as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 631 nanoseconds. - Weight::from_ref_time(864_351 as u64) - // Standard Error: 211 - .saturating_add(Weight::from_ref_time(345_348 as u64).saturating_mul(r as u64)) + // Minimum execution time: 686 nanoseconds. + Weight::from_ref_time(895_726 as u64) + // Standard Error: 144 + .saturating_add(Weight::from_ref_time(344_525 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 789 nanoseconds. - Weight::from_ref_time(1_394_539 as u64) - // Standard Error: 1_038 - .saturating_add(Weight::from_ref_time(971_005 as u64).saturating_mul(r as u64)) + // Minimum execution time: 780 nanoseconds. + Weight::from_ref_time(590_334 as u64) + // Standard Error: 10_839 + .saturating_add(Weight::from_ref_time(1_038_503 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 754 nanoseconds. - Weight::from_ref_time(1_128_787 as u64) - // Standard Error: 233 - .saturating_add(Weight::from_ref_time(878_596 as u64).saturating_mul(r as u64)) + // Minimum execution time: 755 nanoseconds. + Weight::from_ref_time(1_139_912 as u64) + // Standard Error: 466 + .saturating_add(Weight::from_ref_time(881_780 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(934_834 as u64) - // Standard Error: 342 - .saturating_add(Weight::from_ref_time(960_187 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(941_845 as u64) + // Standard Error: 227 + .saturating_add(Weight::from_ref_time(956_897 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 627 nanoseconds. - Weight::from_ref_time(598_327 as u64) - // Standard Error: 504 - .saturating_add(Weight::from_ref_time(1_302_709 as u64).saturating_mul(r as u64)) + // Minimum execution time: 676 nanoseconds. + Weight::from_ref_time(600_675 as u64) + // Standard Error: 555 + .saturating_add(Weight::from_ref_time(1_294_447 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(1_125_699 as u64) - // Standard Error: 838 - .saturating_add(Weight::from_ref_time(533_809 as u64).saturating_mul(r as u64)) + // Minimum execution time: 680 nanoseconds. + Weight::from_ref_time(1_192_340 as u64) + // Standard Error: 897 + .saturating_add(Weight::from_ref_time(524_835 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(1_055_669 as u64) - // Standard Error: 2_735 - .saturating_add(Weight::from_ref_time(805_830 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(1_136_213 as u64) + // Standard Error: 1_137 + .saturating_add(Weight::from_ref_time(791_920 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 687 nanoseconds. - Weight::from_ref_time(543_603 as u64) - // Standard Error: 1_877 - .saturating_add(Weight::from_ref_time(1_083_080 as u64).saturating_mul(r as u64)) + // Minimum execution time: 669 nanoseconds. + Weight::from_ref_time(491_588 as u64) + // Standard Error: 2_098 + .saturating_add(Weight::from_ref_time(1_078_017 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 2_143 nanoseconds. - Weight::from_ref_time(2_592_361 as u64) + // Minimum execution time: 2_128 nanoseconds. + Weight::from_ref_time(2_565_932 as u64) // Standard Error: 76 - .saturating_add(Weight::from_ref_time(4_980 as u64).saturating_mul(e as u64)) + .saturating_add(Weight::from_ref_time(4_830 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 662 nanoseconds. - Weight::from_ref_time(1_475_621 as u64) - // Standard Error: 2_062 - .saturating_add(Weight::from_ref_time(2_201_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(1_593_317 as u64) + // Standard Error: 2_288 + .saturating_add(Weight::from_ref_time(2_195_453 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 814 nanoseconds. - Weight::from_ref_time(1_978_277 as u64) - // Standard Error: 1_626 - .saturating_add(Weight::from_ref_time(2_816_687 as u64).saturating_mul(r as u64)) + // Minimum execution time: 796 nanoseconds. + Weight::from_ref_time(1_816_603 as u64) + // Standard Error: 2_183 + .saturating_add(Weight::from_ref_time(2_808_821 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 4_200 nanoseconds. - Weight::from_ref_time(5_119_408 as u64) - // Standard Error: 482 - .saturating_add(Weight::from_ref_time(179_490 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_212 nanoseconds. + Weight::from_ref_time(5_097_891 as u64) + // Standard Error: 576 + .saturating_add(Weight::from_ref_time(180_948 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 1_622 nanoseconds. - Weight::from_ref_time(1_884_170 as u64) - // Standard Error: 200 - .saturating_add(Weight::from_ref_time(366_730 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_412 nanoseconds. + Weight::from_ref_time(1_733_015 as u64) + // Standard Error: 215 + .saturating_add(Weight::from_ref_time(366_629 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 1_613 nanoseconds. - Weight::from_ref_time(1_852_996 as u64) - // Standard Error: 180 - .saturating_add(Weight::from_ref_time(383_440 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_436 nanoseconds. + Weight::from_ref_time(1_772_333 as u64) + // Standard Error: 288 + .saturating_add(Weight::from_ref_time(380_886 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 1_556 nanoseconds. - Weight::from_ref_time(1_911_516 as u64) - // Standard Error: 257 - .saturating_add(Weight::from_ref_time(528_015 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_408 nanoseconds. + Weight::from_ref_time(1_731_571 as u64) + // Standard Error: 334 + .saturating_add(Weight::from_ref_time(526_489 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 722 nanoseconds. - Weight::from_ref_time(1_079_902 as u64) - // Standard Error: 757 - .saturating_add(Weight::from_ref_time(816_335 as u64).saturating_mul(r as u64)) + // Minimum execution time: 752 nanoseconds. + Weight::from_ref_time(1_118_170 as u64) + // Standard Error: 302 + .saturating_add(Weight::from_ref_time(809_371 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 736 nanoseconds. - Weight::from_ref_time(989_270 as u64) - // Standard Error: 384 - .saturating_add(Weight::from_ref_time(831_122 as u64).saturating_mul(r as u64)) + // Minimum execution time: 770 nanoseconds. + Weight::from_ref_time(990_414 as u64) + // Standard Error: 331 + .saturating_add(Weight::from_ref_time(831_541 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 773 nanoseconds. - Weight::from_ref_time(1_086_755 as u64) - // Standard Error: 443 - .saturating_add(Weight::from_ref_time(694_504 as u64).saturating_mul(r as u64)) + // Minimum execution time: 783 nanoseconds. + Weight::from_ref_time(992_847 as u64) + // Standard Error: 437 + .saturating_add(Weight::from_ref_time(695_374 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 739 nanoseconds. - Weight::from_ref_time(812_861 as u64) - // Standard Error: 5_072 - .saturating_add(Weight::from_ref_time(183_573_238 as u64).saturating_mul(r as u64)) + // Minimum execution time: 664 nanoseconds. + Weight::from_ref_time(758_730 as u64) + // Standard Error: 5_030 + .saturating_add(Weight::from_ref_time(184_801_569 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 685 nanoseconds. - Weight::from_ref_time(956_397 as u64) - // Standard Error: 343 - .saturating_add(Weight::from_ref_time(509_878 as u64).saturating_mul(r as u64)) + // Minimum execution time: 657 nanoseconds. + Weight::from_ref_time(941_928 as u64) + // Standard Error: 216 + .saturating_add(Weight::from_ref_time(506_159 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 641 nanoseconds. - Weight::from_ref_time(940_299 as u64) - // Standard Error: 309 - .saturating_add(Weight::from_ref_time(513_853 as u64).saturating_mul(r as u64)) + // Minimum execution time: 617 nanoseconds. + Weight::from_ref_time(1_009_437 as u64) + // Standard Error: 435 + .saturating_add(Weight::from_ref_time(512_427 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(924_404 as u64) - // Standard Error: 211 - .saturating_add(Weight::from_ref_time(513_663 as u64).saturating_mul(r as u64)) + // Minimum execution time: 663 nanoseconds. + Weight::from_ref_time(875_558 as u64) + // Standard Error: 394 + .saturating_add(Weight::from_ref_time(513_247 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(1_021_461 as u64) - // Standard Error: 1_878 - .saturating_add(Weight::from_ref_time(525_934 as u64).saturating_mul(r as u64)) + // Minimum execution time: 664 nanoseconds. + Weight::from_ref_time(891_913 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(523_595 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 618 nanoseconds. - Weight::from_ref_time(920_038 as u64) - // Standard Error: 269 - .saturating_add(Weight::from_ref_time(507_263 as u64).saturating_mul(r as u64)) + // Minimum execution time: 638 nanoseconds. + Weight::from_ref_time(1_003_558 as u64) + // Standard Error: 471 + .saturating_add(Weight::from_ref_time(502_671 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 638 nanoseconds. - Weight::from_ref_time(921_016 as u64) - // Standard Error: 208 - .saturating_add(Weight::from_ref_time(507_276 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(892_435 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(504_300 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(918_282 as u64) - // Standard Error: 267 - .saturating_add(Weight::from_ref_time(506_343 as u64).saturating_mul(r as u64)) + // Minimum execution time: 626 nanoseconds. + Weight::from_ref_time(880_015 as u64) + // Standard Error: 229 + .saturating_add(Weight::from_ref_time(503_941 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 683 nanoseconds. - Weight::from_ref_time(912_847 as u64) - // Standard Error: 216 - .saturating_add(Weight::from_ref_time(733_648 as u64).saturating_mul(r as u64)) + // Minimum execution time: 623 nanoseconds. + Weight::from_ref_time(893_955 as u64) + // Standard Error: 238 + .saturating_add(Weight::from_ref_time(731_619 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(937_179 as u64) - // Standard Error: 195 - .saturating_add(Weight::from_ref_time(734_905 as u64).saturating_mul(r as u64)) + // Minimum execution time: 661 nanoseconds. + Weight::from_ref_time(904_145 as u64) + // Standard Error: 210 + .saturating_add(Weight::from_ref_time(730_497 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(928_242 as u64) - // Standard Error: 197 - .saturating_add(Weight::from_ref_time(741_814 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(910_832 as u64) + // Standard Error: 248 + .saturating_add(Weight::from_ref_time(738_960 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 666 nanoseconds. - Weight::from_ref_time(978_908 as u64) - // Standard Error: 212 - .saturating_add(Weight::from_ref_time(743_646 as u64).saturating_mul(r as u64)) + // Minimum execution time: 600 nanoseconds. + Weight::from_ref_time(910_816 as u64) + // Standard Error: 257 + .saturating_add(Weight::from_ref_time(742_585 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 685 nanoseconds. - Weight::from_ref_time(954_961 as u64) - // Standard Error: 215 - .saturating_add(Weight::from_ref_time(747_737 as u64).saturating_mul(r as u64)) + // Minimum execution time: 697 nanoseconds. + Weight::from_ref_time(937_672 as u64) + // Standard Error: 291 + .saturating_add(Weight::from_ref_time(746_511 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 660 nanoseconds. - Weight::from_ref_time(911_765 as u64) - // Standard Error: 251 - .saturating_add(Weight::from_ref_time(747_195 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(920_151 as u64) + // Standard Error: 185 + .saturating_add(Weight::from_ref_time(743_483 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 632 nanoseconds. - Weight::from_ref_time(950_928 as u64) - // Standard Error: 287 - .saturating_add(Weight::from_ref_time(735_938 as u64).saturating_mul(r as u64)) + // Minimum execution time: 622 nanoseconds. + Weight::from_ref_time(914_571 as u64) + // Standard Error: 264 + .saturating_add(Weight::from_ref_time(733_935 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 614 nanoseconds. - Weight::from_ref_time(885_567 as u64) - // Standard Error: 2_216 - .saturating_add(Weight::from_ref_time(747_731 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(914_243 as u64) + // Standard Error: 199 + .saturating_add(Weight::from_ref_time(738_786 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 665 nanoseconds. - Weight::from_ref_time(929_711 as u64) - // Standard Error: 180 - .saturating_add(Weight::from_ref_time(736_449 as u64).saturating_mul(r as u64)) + // Minimum execution time: 625 nanoseconds. + Weight::from_ref_time(1_144_724 as u64) + // Standard Error: 1_367 + .saturating_add(Weight::from_ref_time(729_921 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 655 nanoseconds. - Weight::from_ref_time(918_994 as u64) - // Standard Error: 673 - .saturating_add(Weight::from_ref_time(742_317 as u64).saturating_mul(r as u64)) + // Minimum execution time: 643 nanoseconds. + Weight::from_ref_time(897_337 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(738_471 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(925_471 as u64) - // Standard Error: 207 - .saturating_add(Weight::from_ref_time(720_264 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(921_395 as u64) + // Standard Error: 465 + .saturating_add(Weight::from_ref_time(719_508 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 630 nanoseconds. - Weight::from_ref_time(915_027 as u64) - // Standard Error: 162 - .saturating_add(Weight::from_ref_time(715_446 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(889_319 as u64) + // Standard Error: 392 + .saturating_add(Weight::from_ref_time(714_186 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 658 nanoseconds. - Weight::from_ref_time(944_559 as u64) - // Standard Error: 190 - .saturating_add(Weight::from_ref_time(715_915 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(898_856 as u64) + // Standard Error: 189 + .saturating_add(Weight::from_ref_time(714_302 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 622 nanoseconds. - Weight::from_ref_time(917_324 as u64) - // Standard Error: 447 - .saturating_add(Weight::from_ref_time(1_355_730 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(902_499 as u64) + // Standard Error: 428 + .saturating_add(Weight::from_ref_time(1_346_772 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 643 nanoseconds. - Weight::from_ref_time(899_983 as u64) - // Standard Error: 430 - .saturating_add(Weight::from_ref_time(1_285_187 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(944_381 as u64) + // Standard Error: 389 + .saturating_add(Weight::from_ref_time(1_281_605 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 629 nanoseconds. - Weight::from_ref_time(896_030 as u64) - // Standard Error: 528 - .saturating_add(Weight::from_ref_time(1_401_764 as u64).saturating_mul(r as u64)) + // Minimum execution time: 667 nanoseconds. + Weight::from_ref_time(876_301 as u64) + // Standard Error: 589 + .saturating_add(Weight::from_ref_time(1_397_964 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 609 nanoseconds. - Weight::from_ref_time(859_662 as u64) - // Standard Error: 730 - .saturating_add(Weight::from_ref_time(1_287_681 as u64).saturating_mul(r as u64)) + // Minimum execution time: 611 nanoseconds. + Weight::from_ref_time(865_466 as u64) + // Standard Error: 253 + .saturating_add(Weight::from_ref_time(1_283_803 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 624 nanoseconds. - Weight::from_ref_time(902_285 as u64) - // Standard Error: 171 - .saturating_add(Weight::from_ref_time(721_017 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(882_010 as u64) + // Standard Error: 205 + .saturating_add(Weight::from_ref_time(731_251 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 682 nanoseconds. - Weight::from_ref_time(957_929 as u64) - // Standard Error: 235 - .saturating_add(Weight::from_ref_time(718_864 as u64).saturating_mul(r as u64)) + // Minimum execution time: 638 nanoseconds. + Weight::from_ref_time(917_858 as u64) + // Standard Error: 249 + .saturating_add(Weight::from_ref_time(795_023 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 637 nanoseconds. - Weight::from_ref_time(793_291 as u64) - // Standard Error: 601 - .saturating_add(Weight::from_ref_time(727_384 as u64).saturating_mul(r as u64)) + // Minimum execution time: 636 nanoseconds. + Weight::from_ref_time(892_650 as u64) + // Standard Error: 252 + .saturating_add(Weight::from_ref_time(729_337 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 629 nanoseconds. - Weight::from_ref_time(974_702 as u64) - // Standard Error: 350 - .saturating_add(Weight::from_ref_time(736_068 as u64).saturating_mul(r as u64)) + // Minimum execution time: 648 nanoseconds. + Weight::from_ref_time(918_889 as u64) + // Standard Error: 1_079 + .saturating_add(Weight::from_ref_time(746_835 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 636 nanoseconds. - Weight::from_ref_time(900_404 as u64) - // Standard Error: 355 - .saturating_add(Weight::from_ref_time(738_519 as u64).saturating_mul(r as u64)) + // Minimum execution time: 677 nanoseconds. + Weight::from_ref_time(931_684 as u64) + // Standard Error: 259 + .saturating_add(Weight::from_ref_time(734_540 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(1_000_078 as u64) - // Standard Error: 340 - .saturating_add(Weight::from_ref_time(735_680 as u64).saturating_mul(r as u64)) + // Minimum execution time: 635 nanoseconds. + Weight::from_ref_time(914_996 as u64) + // Standard Error: 611 + .saturating_add(Weight::from_ref_time(735_020 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 621 nanoseconds. - Weight::from_ref_time(933_845 as u64) - // Standard Error: 194 - .saturating_add(Weight::from_ref_time(736_788 as u64).saturating_mul(r as u64)) + // Minimum execution time: 663 nanoseconds. + Weight::from_ref_time(914_333 as u64) + // Standard Error: 169 + .saturating_add(Weight::from_ref_time(734_033 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 640 nanoseconds. - Weight::from_ref_time(932_522 as u64) - // Standard Error: 262 - .saturating_add(Weight::from_ref_time(736_535 as u64).saturating_mul(r as u64)) + // Minimum execution time: 631 nanoseconds. + Weight::from_ref_time(916_503 as u64) + // Standard Error: 224 + .saturating_add(Weight::from_ref_time(736_168 as u64).saturating_mul(r as u64)) } } @@ -1425,17 +1414,17 @@ impl WeightInfo for SubstrateWeight { impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_process_deletion_queue_batch() -> Weight { - // Minimum execution time: 3_254 nanoseconds. - Weight::from_ref_time(3_367_000 as u64) + // Minimum execution time: 3_174 nanoseconds. + Weight::from_ref_time(3_298_000 as u64) .saturating_add(RocksDbWeight::get().reads(1 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `k` is `[0, 1024]`. fn on_initialize_per_trie_key(k: u32, ) -> Weight { - // Minimum execution time: 16_206 nanoseconds. - Weight::from_ref_time(19_434_064 as u64) - // Standard Error: 715 - .saturating_add(Weight::from_ref_time(963_296 as u64).saturating_mul(k as u64)) + // Minimum execution time: 15_218 nanoseconds. + Weight::from_ref_time(15_548_154 as u64) + // Standard Error: 732 + .saturating_add(Weight::from_ref_time(940_242 as u64).saturating_mul(k as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) .saturating_add(RocksDbWeight::get().writes((1 as u64).saturating_mul(k as u64))) @@ -1443,10 +1432,10 @@ impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) /// The range of component `q` is `[0, 128]`. fn on_initialize_per_queue_item(q: u32, ) -> Weight { - // Minimum execution time: 3_130 nanoseconds. - Weight::from_ref_time(18_640_668 as u64) - // Standard Error: 4_357 - .saturating_add(Weight::from_ref_time(1_274_044 as u64).saturating_mul(q as u64)) + // Minimum execution time: 3_096 nanoseconds. + Weight::from_ref_time(14_949_039 as u64) + // Standard Error: 3_466 + .saturating_add(Weight::from_ref_time(1_236_160 as u64).saturating_mul(q as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1454,10 +1443,10 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn reinstrument(c: u32, ) -> Weight { - // Minimum execution time: 29_419 nanoseconds. - Weight::from_ref_time(20_616_893 as u64) - // Standard Error: 44 - .saturating_add(Weight::from_ref_time(47_249 as u64).saturating_mul(c as u64)) + // Minimum execution time: 28_333 nanoseconds. + Weight::from_ref_time(19_421_544 as u64) + // Standard Error: 92 + .saturating_add(Weight::from_ref_time(47_629 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } @@ -1468,10 +1457,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `c` is `[0, 131072]`. fn call_with_code_per_byte(c: u32, ) -> Weight { - // Minimum execution time: 311_735 nanoseconds. - Weight::from_ref_time(324_179_000 as u64) - // Standard Error: 23 - .saturating_add(Weight::from_ref_time(31_787 as u64).saturating_mul(c as u64)) + // Minimum execution time: 304_381 nanoseconds. + Weight::from_ref_time(315_177_233 as u64) + // Standard Error: 22 + .saturating_add(Weight::from_ref_time(30_372 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1486,12 +1475,12 @@ impl WeightInfo for () { /// The range of component `c` is `[0, 64226]`. /// The range of component `s` is `[0, 1048576]`. fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - // Minimum execution time: 2_187_833 nanoseconds. - Weight::from_ref_time(419_021_666 as u64) - // Standard Error: 64 - .saturating_add(Weight::from_ref_time(91_150 as u64).saturating_mul(c as u64)) - // Standard Error: 3 - .saturating_add(Weight::from_ref_time(1_767 as u64).saturating_mul(s as u64)) + // Minimum execution time: 2_119_963 nanoseconds. + Weight::from_ref_time(337_976_516 as u64) + // Standard Error: 84 + .saturating_add(Weight::from_ref_time(88_566 as u64).saturating_mul(c as u64)) + // Standard Error: 5 + .saturating_add(Weight::from_ref_time(1_747 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(9 as u64)) } @@ -1504,10 +1493,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `s` is `[0, 1048576]`. fn instantiate(s: u32, ) -> Weight { - // Minimum execution time: 193_073 nanoseconds. - Weight::from_ref_time(177_294_408 as u64) + // Minimum execution time: 184_739 nanoseconds. + Weight::from_ref_time(179_778_057 as u64) // Standard Error: 2 - .saturating_add(Weight::from_ref_time(1_563 as u64).saturating_mul(s as u64)) + .saturating_add(Weight::from_ref_time(1_487 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().writes(7 as u64)) } @@ -1517,8 +1506,8 @@ impl WeightInfo for () { // Storage: System Account (r:1 w:1) // Storage: System EventTopics (r:2 w:2) fn call() -> Weight { - // Minimum execution time: 160_898 nanoseconds. - Weight::from_ref_time(161_990_000 as u64) + // Minimum execution time: 154_711 nanoseconds. + Weight::from_ref_time(155_527_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1528,10 +1517,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:0 w:1) /// The range of component `c` is `[0, 64226]`. fn upload_code(c: u32, ) -> Weight { - // Minimum execution time: 305_859 nanoseconds. - Weight::from_ref_time(309_986_743 as u64) - // Standard Error: 65 - .saturating_add(Weight::from_ref_time(91_731 as u64).saturating_mul(c as u64)) + // Minimum execution time: 294_982 nanoseconds. + Weight::from_ref_time(302_482_450 as u64) + // Standard Error: 62 + .saturating_add(Weight::from_ref_time(88_358 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1540,8 +1529,8 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - // Minimum execution time: 41_544 nanoseconds. - Weight::from_ref_time(41_956_000 as u64) + // Minimum execution time: 39_655 nanoseconds. + Weight::from_ref_time(40_147_000 as u64) .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(4 as u64)) } @@ -1549,8 +1538,8 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:2 w:2) // Storage: System EventTopics (r:3 w:3) fn set_code() -> Weight { - // Minimum execution time: 43_313 nanoseconds. - Weight::from_ref_time(43_987_000 as u64) + // Minimum execution time: 41_028 nanoseconds. + Weight::from_ref_time(41_565_000 as u64) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(6 as u64)) } @@ -1561,10 +1550,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller(r: u32, ) -> Weight { - // Minimum execution time: 300_251 nanoseconds. - Weight::from_ref_time(308_118_154 as u64) - // Standard Error: 13_919 - .saturating_add(Weight::from_ref_time(16_555_470 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_231 nanoseconds. + Weight::from_ref_time(298_245_008 as u64) + // Standard Error: 41_817 + .saturating_add(Weight::from_ref_time(16_183_097 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1575,10 +1564,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_is_contract(r: u32, ) -> Weight { - // Minimum execution time: 302_090 nanoseconds. - Weight::from_ref_time(237_951_992 as u64) - // Standard Error: 425_584 - .saturating_add(Weight::from_ref_time(213_514_628 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_152 nanoseconds. + Weight::from_ref_time(231_239_439 as u64) + // Standard Error: 475_771 + .saturating_add(Weight::from_ref_time(193_804_587 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1590,10 +1579,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 303_203 nanoseconds. - Weight::from_ref_time(263_005_297 as u64) - // Standard Error: 376_919 - .saturating_add(Weight::from_ref_time(265_396_805 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_171 nanoseconds. + Weight::from_ref_time(244_339_298 as u64) + // Standard Error: 440_060 + .saturating_add(Weight::from_ref_time(236_224_857 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1605,10 +1594,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_own_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 304_113 nanoseconds. - Weight::from_ref_time(311_754_829 as u64) - // Standard Error: 18_343 - .saturating_add(Weight::from_ref_time(19_940_285 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_891 nanoseconds. + Weight::from_ref_time(298_061_159 as u64) + // Standard Error: 30_013 + .saturating_add(Weight::from_ref_time(19_682_309 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1619,10 +1608,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_caller_is_origin(r: u32, ) -> Weight { - // Minimum execution time: 301_259 nanoseconds. - Weight::from_ref_time(308_994_291 as u64) - // Standard Error: 14_116 - .saturating_add(Weight::from_ref_time(11_176_417 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_259 nanoseconds. + Weight::from_ref_time(296_675_355 as u64) + // Standard Error: 24_508 + .saturating_add(Weight::from_ref_time(10_949_451 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1633,10 +1622,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_address(r: u32, ) -> Weight { - // Minimum execution time: 301_414 nanoseconds. - Weight::from_ref_time(310_130_007 as u64) - // Standard Error: 21_977 - .saturating_add(Weight::from_ref_time(16_288_617 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_507 nanoseconds. + Weight::from_ref_time(295_682_709 as u64) + // Standard Error: 43_685 + .saturating_add(Weight::from_ref_time(16_461_873 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1647,10 +1636,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas_left(r: u32, ) -> Weight { - // Minimum execution time: 300_342 nanoseconds. - Weight::from_ref_time(308_941_812 as u64) - // Standard Error: 15_417 - .saturating_add(Weight::from_ref_time(16_046_689 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_473 nanoseconds. + Weight::from_ref_time(296_523_274 as u64) + // Standard Error: 34_356 + .saturating_add(Weight::from_ref_time(15_932_835 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1661,10 +1650,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_balance(r: u32, ) -> Weight { - // Minimum execution time: 300_133 nanoseconds. - Weight::from_ref_time(311_277_478 as u64) - // Standard Error: 35_954 - .saturating_add(Weight::from_ref_time(97_275_936 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_889 nanoseconds. + Weight::from_ref_time(295_471_068 as u64) + // Standard Error: 88_937 + .saturating_add(Weight::from_ref_time(89_606_655 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1675,10 +1664,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_value_transferred(r: u32, ) -> Weight { - // Minimum execution time: 299_980 nanoseconds. - Weight::from_ref_time(308_487_901 as u64) - // Standard Error: 15_791 - .saturating_add(Weight::from_ref_time(15_971_242 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_747 nanoseconds. + Weight::from_ref_time(297_023_967 as u64) + // Standard Error: 18_756 + .saturating_add(Weight::from_ref_time(15_748_008 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1689,10 +1678,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_minimum_balance(r: u32, ) -> Weight { - // Minimum execution time: 300_042 nanoseconds. - Weight::from_ref_time(308_378_169 as u64) - // Standard Error: 13_644 - .saturating_add(Weight::from_ref_time(15_940_362 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_590 nanoseconds. + Weight::from_ref_time(296_257_202 as u64) + // Standard Error: 24_863 + .saturating_add(Weight::from_ref_time(15_851_537 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1703,10 +1692,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_block_number(r: u32, ) -> Weight { - // Minimum execution time: 299_913 nanoseconds. - Weight::from_ref_time(306_528_553 as u64) - // Standard Error: 18_702 - .saturating_add(Weight::from_ref_time(16_259_237 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_746 nanoseconds. + Weight::from_ref_time(297_308_097 as u64) + // Standard Error: 29_585 + .saturating_add(Weight::from_ref_time(15_608_985 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1717,10 +1706,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_now(r: u32, ) -> Weight { - // Minimum execution time: 300_639 nanoseconds. - Weight::from_ref_time(310_298_448 as u64) - // Standard Error: 20_201 - .saturating_add(Weight::from_ref_time(15_923_667 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_662 nanoseconds. + Weight::from_ref_time(296_393_072 as u64) + // Standard Error: 23_750 + .saturating_add(Weight::from_ref_time(15_891_911 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1732,10 +1721,10 @@ impl WeightInfo for () { // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_weight_to_fee(r: u32, ) -> Weight { - // Minimum execution time: 300_200 nanoseconds. - Weight::from_ref_time(312_744_329 as u64) - // Standard Error: 33_748 - .saturating_add(Weight::from_ref_time(88_361_056 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_036 nanoseconds. + Weight::from_ref_time(301_071_620 as u64) + // Standard Error: 85_146 + .saturating_add(Weight::from_ref_time(84_455_768 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1746,10 +1735,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_gas(r: u32, ) -> Weight { - // Minimum execution time: 148_130 nanoseconds. - Weight::from_ref_time(151_542_553 as u64) - // Standard Error: 9_571 - .saturating_add(Weight::from_ref_time(8_134_705 as u64).saturating_mul(r as u64)) + // Minimum execution time: 142_655 nanoseconds. + Weight::from_ref_time(145_691_226 as u64) + // Standard Error: 11_085 + .saturating_add(Weight::from_ref_time(7_953_680 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1760,10 +1749,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_input(r: u32, ) -> Weight { - // Minimum execution time: 299_987 nanoseconds. - Weight::from_ref_time(307_696_695 as u64) - // Standard Error: 15_723 - .saturating_add(Weight::from_ref_time(14_189_895 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_613 nanoseconds. + Weight::from_ref_time(296_889_714 as u64) + // Standard Error: 21_550 + .saturating_add(Weight::from_ref_time(13_672_097 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1774,10 +1763,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_input_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 318_276 nanoseconds. - Weight::from_ref_time(335_793_925 as u64) - // Standard Error: 1_344 - .saturating_add(Weight::from_ref_time(9_778_604 as u64).saturating_mul(n as u64)) + // Minimum execution time: 309_866 nanoseconds. + Weight::from_ref_time(328_331_386 as u64) + // Standard Error: 6_205 + .saturating_add(Weight::from_ref_time(9_619_067 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1788,10 +1777,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_return(r: u32, ) -> Weight { - // Minimum execution time: 296_050 nanoseconds. - Weight::from_ref_time(303_863_300 as u64) - // Standard Error: 227_870 - .saturating_add(Weight::from_ref_time(235_100 as u64).saturating_mul(r as u64)) + // Minimum execution time: 288_265 nanoseconds. + Weight::from_ref_time(292_739_779 as u64) + // Standard Error: 108_313 + .saturating_add(Weight::from_ref_time(1_475_820 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1802,10 +1791,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_return_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 299_553 nanoseconds. - Weight::from_ref_time(304_972_388 as u64) - // Standard Error: 262 - .saturating_add(Weight::from_ref_time(197_295 as u64).saturating_mul(n as u64)) + // Minimum execution time: 293_044 nanoseconds. + Weight::from_ref_time(293_846_263 as u64) + // Standard Error: 641 + .saturating_add(Weight::from_ref_time(188_770 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1818,10 +1807,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:1 w:1) /// The range of component `r` is `[0, 1]`. fn seal_terminate(r: u32, ) -> Weight { - // Minimum execution time: 299_708 nanoseconds. - Weight::from_ref_time(306_055_389 as u64) - // Standard Error: 198_678 - .saturating_add(Weight::from_ref_time(57_427_210 as u64).saturating_mul(r as u64)) + // Minimum execution time: 289_248 nanoseconds. + Weight::from_ref_time(294_406_912 as u64) + // Standard Error: 112_528 + .saturating_add(Weight::from_ref_time(52_650_987 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((5 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1835,10 +1824,10 @@ impl WeightInfo for () { // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) /// The range of component `r` is `[0, 20]`. fn seal_random(r: u32, ) -> Weight { - // Minimum execution time: 297_866 nanoseconds. - Weight::from_ref_time(311_103_336 as u64) - // Standard Error: 38_424 - .saturating_add(Weight::from_ref_time(112_211_212 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_980 nanoseconds. + Weight::from_ref_time(298_232_040 as u64) + // Standard Error: 85_517 + .saturating_add(Weight::from_ref_time(108_891_823 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1849,10 +1838,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_deposit_event(r: u32, ) -> Weight { - // Minimum execution time: 297_574 nanoseconds. - Weight::from_ref_time(311_916_564 as u64) - // Standard Error: 62_376 - .saturating_add(Weight::from_ref_time(224_881_274 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_668 nanoseconds. + Weight::from_ref_time(302_010_570 as u64) + // Standard Error: 109_901 + .saturating_add(Weight::from_ref_time(214_667_762 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -1864,12 +1853,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 4]`. /// The range of component `n` is `[0, 16]`. fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - // Minimum execution time: 1_234_995 nanoseconds. - Weight::from_ref_time(510_845_948 as u64) - // Standard Error: 447_066 - .saturating_add(Weight::from_ref_time(188_646_130 as u64).saturating_mul(t as u64)) - // Standard Error: 122_786 - .saturating_add(Weight::from_ref_time(72_057_262 as u64).saturating_mul(n as u64)) + // Minimum execution time: 1_163_533 nanoseconds. + Weight::from_ref_time(501_280_410 as u64) + // Standard Error: 601_576 + .saturating_add(Weight::from_ref_time(172_210_846 as u64).saturating_mul(t as u64)) + // Standard Error: 165_221 + .saturating_add(Weight::from_ref_time(67_584_003 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1882,20 +1871,20 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_debug_message(r: u32, ) -> Weight { - // Minimum execution time: 161_631 nanoseconds. - Weight::from_ref_time(164_876_481 as u64) - // Standard Error: 13_873 - .saturating_add(Weight::from_ref_time(13_009_186 as u64).saturating_mul(r as u64)) + // Minimum execution time: 154_390 nanoseconds. + Weight::from_ref_time(158_246_775 as u64) + // Standard Error: 23_812 + .saturating_add(Weight::from_ref_time(12_810_293 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_set_storage(r: u32, ) -> Weight { - // Minimum execution time: 301_039 nanoseconds. - Weight::from_ref_time(251_149_124 as u64) - // Standard Error: 549_293 - .saturating_add(Weight::from_ref_time(445_621_099 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_926 nanoseconds. + Weight::from_ref_time(250_238_246 as u64) + // Standard Error: 485_292 + .saturating_add(Weight::from_ref_time(402_779_709 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1904,10 +1893,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - // Minimum execution time: 435_530 nanoseconds. - Weight::from_ref_time(614_238_840 as u64) - // Standard Error: 1_623_692 - .saturating_add(Weight::from_ref_time(101_595_333 as u64).saturating_mul(n as u64)) + // Minimum execution time: 421_504 nanoseconds. + Weight::from_ref_time(574_267_945 as u64) + // Standard Error: 1_407_019 + .saturating_add(Weight::from_ref_time(89_516_682 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(52 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(50 as u64)) @@ -1916,10 +1905,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - // Minimum execution time: 436_827 nanoseconds. - Weight::from_ref_time(594_521_125 as u64) - // Standard Error: 1_460_598 - .saturating_add(Weight::from_ref_time(68_080_949 as u64).saturating_mul(n as u64)) + // Minimum execution time: 421_422 nanoseconds. + Weight::from_ref_time(545_948_271 as u64) + // Standard Error: 1_148_143 + .saturating_add(Weight::from_ref_time(63_958_096 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(49 as u64)) @@ -1928,10 +1917,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_clear_storage(r: u32, ) -> Weight { - // Minimum execution time: 300_911 nanoseconds. - Weight::from_ref_time(252_994_248 as u64) - // Standard Error: 538_853 - .saturating_add(Weight::from_ref_time(438_726_157 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_545 nanoseconds. + Weight::from_ref_time(255_622_312 as u64) + // Standard Error: 407_862 + .saturating_add(Weight::from_ref_time(396_764_962 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1940,10 +1929,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 403_401 nanoseconds. - Weight::from_ref_time(577_182_970 as u64) - // Standard Error: 1_589_458 - .saturating_add(Weight::from_ref_time(69_873_104 as u64).saturating_mul(n as u64)) + // Minimum execution time: 390_339 nanoseconds. + Weight::from_ref_time(528_774_888 as u64) + // Standard Error: 1_278_188 + .saturating_add(Weight::from_ref_time(66_683_698 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -1952,10 +1941,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_get_storage(r: u32, ) -> Weight { - // Minimum execution time: 302_119 nanoseconds. - Weight::from_ref_time(265_001_135 as u64) - // Standard Error: 456_550 - .saturating_add(Weight::from_ref_time(358_664_775 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_904 nanoseconds. + Weight::from_ref_time(265_679_354 as u64) + // Standard Error: 386_673 + .saturating_add(Weight::from_ref_time(318_869_116 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1963,10 +1952,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_get_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 385_096 nanoseconds. - Weight::from_ref_time(537_450_417 as u64) - // Standard Error: 1_425_876 - .saturating_add(Weight::from_ref_time(155_746_820 as u64).saturating_mul(n as u64)) + // Minimum execution time: 372_784 nanoseconds. + Weight::from_ref_time(487_784_160 as u64) + // Standard Error: 1_092_850 + .saturating_add(Weight::from_ref_time(152_413_290 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1974,10 +1963,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_contains_storage(r: u32, ) -> Weight { - // Minimum execution time: 301_421 nanoseconds. - Weight::from_ref_time(262_762_745 as u64) - // Standard Error: 497_962 - .saturating_add(Weight::from_ref_time(341_682_818 as u64).saturating_mul(r as u64)) + // Minimum execution time: 301_191 nanoseconds. + Weight::from_ref_time(270_493_545 as u64) + // Standard Error: 373_565 + .saturating_add(Weight::from_ref_time(302_870_977 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1985,10 +1974,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 379_167 nanoseconds. - Weight::from_ref_time(514_239_503 as u64) - // Standard Error: 1_257_747 - .saturating_add(Weight::from_ref_time(64_734_189 as u64).saturating_mul(n as u64)) + // Minimum execution time: 368_641 nanoseconds. + Weight::from_ref_time(469_340_170 as u64) + // Standard Error: 966_589 + .saturating_add(Weight::from_ref_time(62_000_083 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -1996,10 +1985,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `r` is `[0, 10]`. fn seal_take_storage(r: u32, ) -> Weight { - // Minimum execution time: 300_365 nanoseconds. - Weight::from_ref_time(256_283_472 as u64) - // Standard Error: 517_040 - .saturating_add(Weight::from_ref_time(455_679_763 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_717 nanoseconds. + Weight::from_ref_time(254_308_806 as u64) + // Standard Error: 443_802 + .saturating_add(Weight::from_ref_time(408_899_238 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2008,10 +1997,10 @@ impl WeightInfo for () { // Storage: Skipped Metadata (r:0 w:0) /// The range of component `n` is `[0, 8]`. fn seal_take_storage_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 406_491 nanoseconds. - Weight::from_ref_time(593_727_170 as u64) - // Standard Error: 1_715_624 - .saturating_add(Weight::from_ref_time(163_630_716 as u64).saturating_mul(n as u64)) + // Minimum execution time: 396_211 nanoseconds. + Weight::from_ref_time(545_169_999 as u64) + // Standard Error: 1_390_049 + .saturating_add(Weight::from_ref_time(156_931_202 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(51 as u64)) .saturating_add(RocksDbWeight::get().reads((7 as u64).saturating_mul(n as u64))) .saturating_add(RocksDbWeight::get().writes(48 as u64)) @@ -2024,10 +2013,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_transfer(r: u32, ) -> Weight { - // Minimum execution time: 302_533 nanoseconds. - Weight::from_ref_time(266_693_382 as u64) - // Standard Error: 510_705 - .saturating_add(Weight::from_ref_time(1_380_402_053 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_145 nanoseconds. + Weight::from_ref_time(241_332_033 as u64) + // Standard Error: 658_837 + .saturating_add(Weight::from_ref_time(1_315_958_335 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((80 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(4 as u64)) @@ -2040,10 +2029,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_call(r: u32, ) -> Weight { - // Minimum execution time: 303_609 nanoseconds. - Weight::from_ref_time(605_684_212 as u64) - // Standard Error: 9_562_866 - .saturating_add(Weight::from_ref_time(20_814_449_121 as u64).saturating_mul(r as u64)) + // Minimum execution time: 295_624 nanoseconds. + Weight::from_ref_time(296_567_000 as u64) + // Standard Error: 6_725_484 + .saturating_add(Weight::from_ref_time(20_773_662_959 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(7 as u64)) .saturating_add(RocksDbWeight::get().reads((160 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2056,10 +2045,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. fn seal_delegate_call(r: u32, ) -> Weight { - // Minimum execution time: 295_036 nanoseconds. - Weight::from_ref_time(299_300_000 as u64) - // Standard Error: 6_617_504 - .saturating_add(Weight::from_ref_time(20_495_640_402 as u64).saturating_mul(r as u64)) + // Minimum execution time: 296_698 nanoseconds. + Weight::from_ref_time(297_541_000 as u64) + // Standard Error: 18_681_855 + .saturating_add(Weight::from_ref_time(20_702_951_248 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((150 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2073,12 +2062,12 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `c` is `[0, 1024]`. fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight { - // Minimum execution time: 9_539_055 nanoseconds. - Weight::from_ref_time(8_483_664_501 as u64) - // Standard Error: 7_679_615 - .saturating_add(Weight::from_ref_time(1_308_202_444 as u64).saturating_mul(t as u64)) - // Standard Error: 11_515 - .saturating_add(Weight::from_ref_time(9_772_393 as u64).saturating_mul(c as u64)) + // Minimum execution time: 9_491_225 nanoseconds. + Weight::from_ref_time(8_726_446_640 as u64) + // Standard Error: 11_723_053 + .saturating_add(Weight::from_ref_time(1_107_970_775 as u64).saturating_mul(t as u64)) + // Standard Error: 17_578 + .saturating_add(Weight::from_ref_time(9_748_009 as u64).saturating_mul(c as u64)) .saturating_add(RocksDbWeight::get().reads(167 as u64)) .saturating_add(RocksDbWeight::get().reads((81 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(163 as u64)) @@ -2093,10 +2082,10 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:80 w:80) /// The range of component `r` is `[0, 20]`. fn seal_instantiate(r: u32, ) -> Weight { - // Minimum execution time: 295_735 nanoseconds. - Weight::from_ref_time(297_194_000 as u64) - // Standard Error: 19_981_805 - .saturating_add(Weight::from_ref_time(26_085_707_987 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_351 nanoseconds. + Weight::from_ref_time(297_837_000 as u64) + // Standard Error: 17_115_732 + .saturating_add(Weight::from_ref_time(25_936_348_025 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(8 as u64)) .saturating_add(RocksDbWeight::get().reads((400 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(5 as u64)) @@ -2112,10 +2101,10 @@ impl WeightInfo for () { /// The range of component `t` is `[0, 1]`. /// The range of component `s` is `[0, 960]`. fn seal_instantiate_per_transfer_salt_kb(t: u32, s: u32, ) -> Weight { - // Minimum execution time: 11_604_541 nanoseconds. - Weight::from_ref_time(11_654_911_938 as u64) - // Standard Error: 70_387 - .saturating_add(Weight::from_ref_time(122_480_891 as u64).saturating_mul(s as u64)) + // Minimum execution time: 11_367_191 nanoseconds. + Weight::from_ref_time(11_186_726_411 as u64) + // Standard Error: 75_273 + .saturating_add(Weight::from_ref_time(122_421_705 as u64).saturating_mul(s as u64)) .saturating_add(RocksDbWeight::get().reads(249 as u64)) .saturating_add(RocksDbWeight::get().reads((1 as u64).saturating_mul(t as u64))) .saturating_add(RocksDbWeight::get().writes(247 as u64)) @@ -2128,10 +2117,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_sha2_256(r: u32, ) -> Weight { - // Minimum execution time: 291_842 nanoseconds. - Weight::from_ref_time(298_528_736 as u64) - // Standard Error: 221_776 - .saturating_add(Weight::from_ref_time(41_330_763 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_753 nanoseconds. + Weight::from_ref_time(295_491_471 as u64) + // Standard Error: 112_217 + .saturating_add(Weight::from_ref_time(41_976_228 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2142,10 +2131,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 335_273 nanoseconds. - Weight::from_ref_time(339_286_000 as u64) - // Standard Error: 60_137 - .saturating_add(Weight::from_ref_time(323_505_025 as u64).saturating_mul(n as u64)) + // Minimum execution time: 335_784 nanoseconds. + Weight::from_ref_time(336_406_000 as u64) + // Standard Error: 58_205 + .saturating_add(Weight::from_ref_time(323_644_833 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2156,10 +2145,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_keccak_256(r: u32, ) -> Weight { - // Minimum execution time: 290_208 nanoseconds. - Weight::from_ref_time(297_912_167 as u64) - // Standard Error: 145_143 - .saturating_add(Weight::from_ref_time(52_787_732 as u64).saturating_mul(r as u64)) + // Minimum execution time: 292_772 nanoseconds. + Weight::from_ref_time(294_845_565 as u64) + // Standard Error: 118_932 + .saturating_add(Weight::from_ref_time(53_186_034 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2170,10 +2159,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 345_905 nanoseconds. - Weight::from_ref_time(350_585_000 as u64) - // Standard Error: 58_069 - .saturating_add(Weight::from_ref_time(247_905_263 as u64).saturating_mul(n as u64)) + // Minimum execution time: 348_057 nanoseconds. + Weight::from_ref_time(354_903_000 as u64) + // Standard Error: 63_036 + .saturating_add(Weight::from_ref_time(247_852_636 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2184,10 +2173,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_256(r: u32, ) -> Weight { - // Minimum execution time: 290_053 nanoseconds. - Weight::from_ref_time(297_967_508 as u64) - // Standard Error: 130_197 - .saturating_add(Weight::from_ref_time(32_326_891 as u64).saturating_mul(r as u64)) + // Minimum execution time: 290_417 nanoseconds. + Weight::from_ref_time(295_285_706 as u64) + // Standard Error: 124_630 + .saturating_add(Weight::from_ref_time(31_293_293 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2198,10 +2187,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 324_904 nanoseconds. - Weight::from_ref_time(329_481_000 as u64) - // Standard Error: 51_824 - .saturating_add(Weight::from_ref_time(99_701_756 as u64).saturating_mul(n as u64)) + // Minimum execution time: 325_903 nanoseconds. + Weight::from_ref_time(326_482_000 as u64) + // Standard Error: 47_465 + .saturating_add(Weight::from_ref_time(99_615_769 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2212,10 +2201,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_hash_blake2_128(r: u32, ) -> Weight { - // Minimum execution time: 287_563 nanoseconds. - Weight::from_ref_time(296_961_751 as u64) - // Standard Error: 234_387 - .saturating_add(Weight::from_ref_time(30_922_648 as u64).saturating_mul(r as u64)) + // Minimum execution time: 291_624 nanoseconds. + Weight::from_ref_time(295_781_938 as u64) + // Standard Error: 849_772 + .saturating_add(Weight::from_ref_time(30_869_061 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2226,10 +2215,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `n` is `[0, 1024]`. fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - // Minimum execution time: 323_485 nanoseconds. - Weight::from_ref_time(328_169_000 as u64) - // Standard Error: 49_606 - .saturating_add(Weight::from_ref_time(99_726_280 as u64).saturating_mul(n as u64)) + // Minimum execution time: 323_456 nanoseconds. + Weight::from_ref_time(324_815_000 as u64) + // Standard Error: 49_126 + .saturating_add(Weight::from_ref_time(99_651_878 as u64).saturating_mul(n as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2240,10 +2229,10 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_recover(r: u32, ) -> Weight { - // Minimum execution time: 289_611 nanoseconds. - Weight::from_ref_time(299_478_153 as u64) - // Standard Error: 466_179 - .saturating_add(Weight::from_ref_time(3_032_914_046 as u64).saturating_mul(r as u64)) + // Minimum execution time: 294_244 nanoseconds. + Weight::from_ref_time(296_117_277 as u64) + // Standard Error: 513_100 + .saturating_add(Weight::from_ref_time(3_005_168_422 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2254,23 +2243,13 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 1]`. fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight { - // Minimum execution time: 292_544 nanoseconds. - Weight::from_ref_time(299_101_359 as u64) - // Standard Error: 435_234 - .saturating_add(Weight::from_ref_time(2_043_545_340 as u64).saturating_mul(r as u64)) + // Minimum execution time: 293_099 nanoseconds. + Weight::from_ref_time(295_349_591 as u64) + // Standard Error: 437_688 + .saturating_add(Weight::from_ref_time(2_079_472_608 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } - fn seal_set_code_hash(r: u32, ) -> Weight { - // Minimum execution time: 293_390 nanoseconds. - Weight::from_ref_time(297_791_000 as u64) - // Standard Error: 2_704_135 - .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) - .saturating_add(RocksDbWeight::get().reads(6 as u64)) - .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) - .saturating_add(RocksDbWeight::get().writes(3 as u64)) - .saturating_add(RocksDbWeight::get().writes((150 as u64).saturating_mul(r as u64))) - } // Storage: System Account (r:1 w:0) // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) @@ -2278,11 +2257,11 @@ impl WeightInfo for () { // Storage: System EventTopics (r:2 w:2) // Storage: Contracts OwnerInfoOf (r:16 w:16) /// The range of component `r` is `[0, 20]`. - fn seal_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 293_390 nanoseconds. - Weight::from_ref_time(297_791_000 as u64) - // Standard Error: 2_704_135 - .saturating_add(Weight::from_ref_time(1_426_040_282 as u64).saturating_mul(r as u64)) + fn seal_set_code_hash(r: u32, ) -> Weight { + // Minimum execution time: 293_692 nanoseconds. + Weight::from_ref_time(294_871_000 as u64) + // Standard Error: 2_737_018 + .saturating_add(Weight::from_ref_time(1_360_098_499 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().reads((225 as u64).saturating_mul(r as u64))) .saturating_add(RocksDbWeight::get().writes(3 as u64)) @@ -2294,11 +2273,11 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn seal_account_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 294_837 nanoseconds. - Weight::from_ref_time(304_337_243 as u64) - // Standard Error: 43_642 - .saturating_add(Weight::from_ref_time(10_830_982 as u64).saturating_mul(r as u64)) + fn seal_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 295_570 nanoseconds. + Weight::from_ref_time(299_077_520 as u64) + // Standard Error: 23_516 + .saturating_add(Weight::from_ref_time(10_971_589 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } @@ -2308,369 +2287,369 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:2 w:2) /// The range of component `r` is `[0, 20]`. - fn account_reentrance_count(r: u32, ) -> Weight { - // Minimum execution time: 294_852 nanoseconds. - Weight::from_ref_time(343_714_525 as u64) - // Standard Error: 140_657 - .saturating_add(Weight::from_ref_time(24_444_391 as u64).saturating_mul(r as u64)) + fn seal_account_reentrance_count(r: u32, ) -> Weight { + // Minimum execution time: 296_873 nanoseconds. + Weight::from_ref_time(336_309_706 as u64) + // Standard Error: 125_484 + .saturating_add(Weight::from_ref_time(25_321_948 as u64).saturating_mul(r as u64)) .saturating_add(RocksDbWeight::get().reads(6 as u64)) .saturating_add(RocksDbWeight::get().writes(3 as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64const(r: u32, ) -> Weight { - // Minimum execution time: 631 nanoseconds. - Weight::from_ref_time(864_351 as u64) - // Standard Error: 211 - .saturating_add(Weight::from_ref_time(345_348 as u64).saturating_mul(r as u64)) + // Minimum execution time: 686 nanoseconds. + Weight::from_ref_time(895_726 as u64) + // Standard Error: 144 + .saturating_add(Weight::from_ref_time(344_525 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64load(r: u32, ) -> Weight { - // Minimum execution time: 789 nanoseconds. - Weight::from_ref_time(1_394_539 as u64) - // Standard Error: 1_038 - .saturating_add(Weight::from_ref_time(971_005 as u64).saturating_mul(r as u64)) + // Minimum execution time: 780 nanoseconds. + Weight::from_ref_time(590_334 as u64) + // Standard Error: 10_839 + .saturating_add(Weight::from_ref_time(1_038_503 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64store(r: u32, ) -> Weight { - // Minimum execution time: 754 nanoseconds. - Weight::from_ref_time(1_128_787 as u64) - // Standard Error: 233 - .saturating_add(Weight::from_ref_time(878_596 as u64).saturating_mul(r as u64)) + // Minimum execution time: 755 nanoseconds. + Weight::from_ref_time(1_139_912 as u64) + // Standard Error: 466 + .saturating_add(Weight::from_ref_time(881_780 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_select(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(934_834 as u64) - // Standard Error: 342 - .saturating_add(Weight::from_ref_time(960_187 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(941_845 as u64) + // Standard Error: 227 + .saturating_add(Weight::from_ref_time(956_897 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_if(r: u32, ) -> Weight { - // Minimum execution time: 627 nanoseconds. - Weight::from_ref_time(598_327 as u64) - // Standard Error: 504 - .saturating_add(Weight::from_ref_time(1_302_709 as u64).saturating_mul(r as u64)) + // Minimum execution time: 676 nanoseconds. + Weight::from_ref_time(600_675 as u64) + // Standard Error: 555 + .saturating_add(Weight::from_ref_time(1_294_447 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(1_125_699 as u64) - // Standard Error: 838 - .saturating_add(Weight::from_ref_time(533_809 as u64).saturating_mul(r as u64)) + // Minimum execution time: 680 nanoseconds. + Weight::from_ref_time(1_192_340 as u64) + // Standard Error: 897 + .saturating_add(Weight::from_ref_time(524_835 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_if(r: u32, ) -> Weight { - // Minimum execution time: 651 nanoseconds. - Weight::from_ref_time(1_055_669 as u64) - // Standard Error: 2_735 - .saturating_add(Weight::from_ref_time(805_830 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(1_136_213 as u64) + // Standard Error: 1_137 + .saturating_add(Weight::from_ref_time(791_920 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_br_table(r: u32, ) -> Weight { - // Minimum execution time: 687 nanoseconds. - Weight::from_ref_time(543_603 as u64) - // Standard Error: 1_877 - .saturating_add(Weight::from_ref_time(1_083_080 as u64).saturating_mul(r as u64)) + // Minimum execution time: 669 nanoseconds. + Weight::from_ref_time(491_588 as u64) + // Standard Error: 2_098 + .saturating_add(Weight::from_ref_time(1_078_017 as u64).saturating_mul(r as u64)) } /// The range of component `e` is `[1, 256]`. fn instr_br_table_per_entry(e: u32, ) -> Weight { - // Minimum execution time: 2_143 nanoseconds. - Weight::from_ref_time(2_592_361 as u64) + // Minimum execution time: 2_128 nanoseconds. + Weight::from_ref_time(2_565_932 as u64) // Standard Error: 76 - .saturating_add(Weight::from_ref_time(4_980 as u64).saturating_mul(e as u64)) + .saturating_add(Weight::from_ref_time(4_830 as u64).saturating_mul(e as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call(r: u32, ) -> Weight { - // Minimum execution time: 662 nanoseconds. - Weight::from_ref_time(1_475_621 as u64) - // Standard Error: 2_062 - .saturating_add(Weight::from_ref_time(2_201_208 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(1_593_317 as u64) + // Standard Error: 2_288 + .saturating_add(Weight::from_ref_time(2_195_453 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_call_indirect(r: u32, ) -> Weight { - // Minimum execution time: 814 nanoseconds. - Weight::from_ref_time(1_978_277 as u64) - // Standard Error: 1_626 - .saturating_add(Weight::from_ref_time(2_816_687 as u64).saturating_mul(r as u64)) + // Minimum execution time: 796 nanoseconds. + Weight::from_ref_time(1_816_603 as u64) + // Standard Error: 2_183 + .saturating_add(Weight::from_ref_time(2_808_821 as u64).saturating_mul(r as u64)) } /// The range of component `p` is `[0, 128]`. fn instr_call_indirect_per_param(p: u32, ) -> Weight { - // Minimum execution time: 4_200 nanoseconds. - Weight::from_ref_time(5_119_408 as u64) - // Standard Error: 482 - .saturating_add(Weight::from_ref_time(179_490 as u64).saturating_mul(p as u64)) + // Minimum execution time: 4_212 nanoseconds. + Weight::from_ref_time(5_097_891 as u64) + // Standard Error: 576 + .saturating_add(Weight::from_ref_time(180_948 as u64).saturating_mul(p as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_get(r: u32, ) -> Weight { - // Minimum execution time: 1_622 nanoseconds. - Weight::from_ref_time(1_884_170 as u64) - // Standard Error: 200 - .saturating_add(Weight::from_ref_time(366_730 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_412 nanoseconds. + Weight::from_ref_time(1_733_015 as u64) + // Standard Error: 215 + .saturating_add(Weight::from_ref_time(366_629 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_set(r: u32, ) -> Weight { - // Minimum execution time: 1_613 nanoseconds. - Weight::from_ref_time(1_852_996 as u64) - // Standard Error: 180 - .saturating_add(Weight::from_ref_time(383_440 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_436 nanoseconds. + Weight::from_ref_time(1_772_333 as u64) + // Standard Error: 288 + .saturating_add(Weight::from_ref_time(380_886 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_local_tee(r: u32, ) -> Weight { - // Minimum execution time: 1_556 nanoseconds. - Weight::from_ref_time(1_911_516 as u64) - // Standard Error: 257 - .saturating_add(Weight::from_ref_time(528_015 as u64).saturating_mul(r as u64)) + // Minimum execution time: 1_408 nanoseconds. + Weight::from_ref_time(1_731_571 as u64) + // Standard Error: 334 + .saturating_add(Weight::from_ref_time(526_489 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_get(r: u32, ) -> Weight { - // Minimum execution time: 722 nanoseconds. - Weight::from_ref_time(1_079_902 as u64) - // Standard Error: 757 - .saturating_add(Weight::from_ref_time(816_335 as u64).saturating_mul(r as u64)) + // Minimum execution time: 752 nanoseconds. + Weight::from_ref_time(1_118_170 as u64) + // Standard Error: 302 + .saturating_add(Weight::from_ref_time(809_371 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_global_set(r: u32, ) -> Weight { - // Minimum execution time: 736 nanoseconds. - Weight::from_ref_time(989_270 as u64) - // Standard Error: 384 - .saturating_add(Weight::from_ref_time(831_122 as u64).saturating_mul(r as u64)) + // Minimum execution time: 770 nanoseconds. + Weight::from_ref_time(990_414 as u64) + // Standard Error: 331 + .saturating_add(Weight::from_ref_time(831_541 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_memory_current(r: u32, ) -> Weight { - // Minimum execution time: 773 nanoseconds. - Weight::from_ref_time(1_086_755 as u64) - // Standard Error: 443 - .saturating_add(Weight::from_ref_time(694_504 as u64).saturating_mul(r as u64)) + // Minimum execution time: 783 nanoseconds. + Weight::from_ref_time(992_847 as u64) + // Standard Error: 437 + .saturating_add(Weight::from_ref_time(695_374 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 1]`. fn instr_memory_grow(r: u32, ) -> Weight { - // Minimum execution time: 739 nanoseconds. - Weight::from_ref_time(812_861 as u64) - // Standard Error: 5_072 - .saturating_add(Weight::from_ref_time(183_573_238 as u64).saturating_mul(r as u64)) + // Minimum execution time: 664 nanoseconds. + Weight::from_ref_time(758_730 as u64) + // Standard Error: 5_030 + .saturating_add(Weight::from_ref_time(184_801_569 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64clz(r: u32, ) -> Weight { - // Minimum execution time: 685 nanoseconds. - Weight::from_ref_time(956_397 as u64) - // Standard Error: 343 - .saturating_add(Weight::from_ref_time(509_878 as u64).saturating_mul(r as u64)) + // Minimum execution time: 657 nanoseconds. + Weight::from_ref_time(941_928 as u64) + // Standard Error: 216 + .saturating_add(Weight::from_ref_time(506_159 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ctz(r: u32, ) -> Weight { - // Minimum execution time: 641 nanoseconds. - Weight::from_ref_time(940_299 as u64) - // Standard Error: 309 - .saturating_add(Weight::from_ref_time(513_853 as u64).saturating_mul(r as u64)) + // Minimum execution time: 617 nanoseconds. + Weight::from_ref_time(1_009_437 as u64) + // Standard Error: 435 + .saturating_add(Weight::from_ref_time(512_427 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64popcnt(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(924_404 as u64) - // Standard Error: 211 - .saturating_add(Weight::from_ref_time(513_663 as u64).saturating_mul(r as u64)) + // Minimum execution time: 663 nanoseconds. + Weight::from_ref_time(875_558 as u64) + // Standard Error: 394 + .saturating_add(Weight::from_ref_time(513_247 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eqz(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(1_021_461 as u64) - // Standard Error: 1_878 - .saturating_add(Weight::from_ref_time(525_934 as u64).saturating_mul(r as u64)) + // Minimum execution time: 664 nanoseconds. + Weight::from_ref_time(891_913 as u64) + // Standard Error: 171 + .saturating_add(Weight::from_ref_time(523_595 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendsi32(r: u32, ) -> Weight { - // Minimum execution time: 618 nanoseconds. - Weight::from_ref_time(920_038 as u64) - // Standard Error: 269 - .saturating_add(Weight::from_ref_time(507_263 as u64).saturating_mul(r as u64)) + // Minimum execution time: 638 nanoseconds. + Weight::from_ref_time(1_003_558 as u64) + // Standard Error: 471 + .saturating_add(Weight::from_ref_time(502_671 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64extendui32(r: u32, ) -> Weight { - // Minimum execution time: 638 nanoseconds. - Weight::from_ref_time(921_016 as u64) - // Standard Error: 208 - .saturating_add(Weight::from_ref_time(507_276 as u64).saturating_mul(r as u64)) + // Minimum execution time: 665 nanoseconds. + Weight::from_ref_time(892_435 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(504_300 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i32wrapi64(r: u32, ) -> Weight { - // Minimum execution time: 628 nanoseconds. - Weight::from_ref_time(918_282 as u64) - // Standard Error: 267 - .saturating_add(Weight::from_ref_time(506_343 as u64).saturating_mul(r as u64)) + // Minimum execution time: 626 nanoseconds. + Weight::from_ref_time(880_015 as u64) + // Standard Error: 229 + .saturating_add(Weight::from_ref_time(503_941 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64eq(r: u32, ) -> Weight { - // Minimum execution time: 683 nanoseconds. - Weight::from_ref_time(912_847 as u64) - // Standard Error: 216 - .saturating_add(Weight::from_ref_time(733_648 as u64).saturating_mul(r as u64)) + // Minimum execution time: 623 nanoseconds. + Weight::from_ref_time(893_955 as u64) + // Standard Error: 238 + .saturating_add(Weight::from_ref_time(731_619 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ne(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(937_179 as u64) - // Standard Error: 195 - .saturating_add(Weight::from_ref_time(734_905 as u64).saturating_mul(r as u64)) + // Minimum execution time: 661 nanoseconds. + Weight::from_ref_time(904_145 as u64) + // Standard Error: 210 + .saturating_add(Weight::from_ref_time(730_497 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64lts(r: u32, ) -> Weight { - // Minimum execution time: 650 nanoseconds. - Weight::from_ref_time(928_242 as u64) - // Standard Error: 197 - .saturating_add(Weight::from_ref_time(741_814 as u64).saturating_mul(r as u64)) + // Minimum execution time: 670 nanoseconds. + Weight::from_ref_time(910_832 as u64) + // Standard Error: 248 + .saturating_add(Weight::from_ref_time(738_960 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ltu(r: u32, ) -> Weight { - // Minimum execution time: 666 nanoseconds. - Weight::from_ref_time(978_908 as u64) - // Standard Error: 212 - .saturating_add(Weight::from_ref_time(743_646 as u64).saturating_mul(r as u64)) + // Minimum execution time: 600 nanoseconds. + Weight::from_ref_time(910_816 as u64) + // Standard Error: 257 + .saturating_add(Weight::from_ref_time(742_585 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gts(r: u32, ) -> Weight { - // Minimum execution time: 685 nanoseconds. - Weight::from_ref_time(954_961 as u64) - // Standard Error: 215 - .saturating_add(Weight::from_ref_time(747_737 as u64).saturating_mul(r as u64)) + // Minimum execution time: 697 nanoseconds. + Weight::from_ref_time(937_672 as u64) + // Standard Error: 291 + .saturating_add(Weight::from_ref_time(746_511 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64gtu(r: u32, ) -> Weight { - // Minimum execution time: 660 nanoseconds. - Weight::from_ref_time(911_765 as u64) - // Standard Error: 251 - .saturating_add(Weight::from_ref_time(747_195 as u64).saturating_mul(r as u64)) + // Minimum execution time: 651 nanoseconds. + Weight::from_ref_time(920_151 as u64) + // Standard Error: 185 + .saturating_add(Weight::from_ref_time(743_483 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64les(r: u32, ) -> Weight { - // Minimum execution time: 632 nanoseconds. - Weight::from_ref_time(950_928 as u64) - // Standard Error: 287 - .saturating_add(Weight::from_ref_time(735_938 as u64).saturating_mul(r as u64)) + // Minimum execution time: 622 nanoseconds. + Weight::from_ref_time(914_571 as u64) + // Standard Error: 264 + .saturating_add(Weight::from_ref_time(733_935 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64leu(r: u32, ) -> Weight { - // Minimum execution time: 614 nanoseconds. - Weight::from_ref_time(885_567 as u64) - // Standard Error: 2_216 - .saturating_add(Weight::from_ref_time(747_731 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(914_243 as u64) + // Standard Error: 199 + .saturating_add(Weight::from_ref_time(738_786 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64ges(r: u32, ) -> Weight { - // Minimum execution time: 665 nanoseconds. - Weight::from_ref_time(929_711 as u64) - // Standard Error: 180 - .saturating_add(Weight::from_ref_time(736_449 as u64).saturating_mul(r as u64)) + // Minimum execution time: 625 nanoseconds. + Weight::from_ref_time(1_144_724 as u64) + // Standard Error: 1_367 + .saturating_add(Weight::from_ref_time(729_921 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64geu(r: u32, ) -> Weight { - // Minimum execution time: 655 nanoseconds. - Weight::from_ref_time(918_994 as u64) - // Standard Error: 673 - .saturating_add(Weight::from_ref_time(742_317 as u64).saturating_mul(r as u64)) + // Minimum execution time: 643 nanoseconds. + Weight::from_ref_time(897_337 as u64) + // Standard Error: 162 + .saturating_add(Weight::from_ref_time(738_471 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64add(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(925_471 as u64) - // Standard Error: 207 - .saturating_add(Weight::from_ref_time(720_264 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(921_395 as u64) + // Standard Error: 465 + .saturating_add(Weight::from_ref_time(719_508 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64sub(r: u32, ) -> Weight { - // Minimum execution time: 630 nanoseconds. - Weight::from_ref_time(915_027 as u64) - // Standard Error: 162 - .saturating_add(Weight::from_ref_time(715_446 as u64).saturating_mul(r as u64)) + // Minimum execution time: 672 nanoseconds. + Weight::from_ref_time(889_319 as u64) + // Standard Error: 392 + .saturating_add(Weight::from_ref_time(714_186 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64mul(r: u32, ) -> Weight { - // Minimum execution time: 658 nanoseconds. - Weight::from_ref_time(944_559 as u64) - // Standard Error: 190 - .saturating_add(Weight::from_ref_time(715_915 as u64).saturating_mul(r as u64)) + // Minimum execution time: 660 nanoseconds. + Weight::from_ref_time(898_856 as u64) + // Standard Error: 189 + .saturating_add(Weight::from_ref_time(714_302 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divs(r: u32, ) -> Weight { - // Minimum execution time: 622 nanoseconds. - Weight::from_ref_time(917_324 as u64) - // Standard Error: 447 - .saturating_add(Weight::from_ref_time(1_355_730 as u64).saturating_mul(r as u64)) + // Minimum execution time: 629 nanoseconds. + Weight::from_ref_time(902_499 as u64) + // Standard Error: 428 + .saturating_add(Weight::from_ref_time(1_346_772 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64divu(r: u32, ) -> Weight { - // Minimum execution time: 643 nanoseconds. - Weight::from_ref_time(899_983 as u64) - // Standard Error: 430 - .saturating_add(Weight::from_ref_time(1_285_187 as u64).saturating_mul(r as u64)) + // Minimum execution time: 624 nanoseconds. + Weight::from_ref_time(944_381 as u64) + // Standard Error: 389 + .saturating_add(Weight::from_ref_time(1_281_605 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rems(r: u32, ) -> Weight { - // Minimum execution time: 629 nanoseconds. - Weight::from_ref_time(896_030 as u64) - // Standard Error: 528 - .saturating_add(Weight::from_ref_time(1_401_764 as u64).saturating_mul(r as u64)) + // Minimum execution time: 667 nanoseconds. + Weight::from_ref_time(876_301 as u64) + // Standard Error: 589 + .saturating_add(Weight::from_ref_time(1_397_964 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64remu(r: u32, ) -> Weight { - // Minimum execution time: 609 nanoseconds. - Weight::from_ref_time(859_662 as u64) - // Standard Error: 730 - .saturating_add(Weight::from_ref_time(1_287_681 as u64).saturating_mul(r as u64)) + // Minimum execution time: 611 nanoseconds. + Weight::from_ref_time(865_466 as u64) + // Standard Error: 253 + .saturating_add(Weight::from_ref_time(1_283_803 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64and(r: u32, ) -> Weight { - // Minimum execution time: 624 nanoseconds. - Weight::from_ref_time(902_285 as u64) - // Standard Error: 171 - .saturating_add(Weight::from_ref_time(721_017 as u64).saturating_mul(r as u64)) + // Minimum execution time: 653 nanoseconds. + Weight::from_ref_time(882_010 as u64) + // Standard Error: 205 + .saturating_add(Weight::from_ref_time(731_251 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64or(r: u32, ) -> Weight { - // Minimum execution time: 682 nanoseconds. - Weight::from_ref_time(957_929 as u64) - // Standard Error: 235 - .saturating_add(Weight::from_ref_time(718_864 as u64).saturating_mul(r as u64)) + // Minimum execution time: 638 nanoseconds. + Weight::from_ref_time(917_858 as u64) + // Standard Error: 249 + .saturating_add(Weight::from_ref_time(795_023 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64xor(r: u32, ) -> Weight { - // Minimum execution time: 637 nanoseconds. - Weight::from_ref_time(793_291 as u64) - // Standard Error: 601 - .saturating_add(Weight::from_ref_time(727_384 as u64).saturating_mul(r as u64)) + // Minimum execution time: 636 nanoseconds. + Weight::from_ref_time(892_650 as u64) + // Standard Error: 252 + .saturating_add(Weight::from_ref_time(729_337 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shl(r: u32, ) -> Weight { - // Minimum execution time: 629 nanoseconds. - Weight::from_ref_time(974_702 as u64) - // Standard Error: 350 - .saturating_add(Weight::from_ref_time(736_068 as u64).saturating_mul(r as u64)) + // Minimum execution time: 648 nanoseconds. + Weight::from_ref_time(918_889 as u64) + // Standard Error: 1_079 + .saturating_add(Weight::from_ref_time(746_835 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shrs(r: u32, ) -> Weight { - // Minimum execution time: 636 nanoseconds. - Weight::from_ref_time(900_404 as u64) - // Standard Error: 355 - .saturating_add(Weight::from_ref_time(738_519 as u64).saturating_mul(r as u64)) + // Minimum execution time: 677 nanoseconds. + Weight::from_ref_time(931_684 as u64) + // Standard Error: 259 + .saturating_add(Weight::from_ref_time(734_540 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64shru(r: u32, ) -> Weight { - // Minimum execution time: 646 nanoseconds. - Weight::from_ref_time(1_000_078 as u64) - // Standard Error: 340 - .saturating_add(Weight::from_ref_time(735_680 as u64).saturating_mul(r as u64)) + // Minimum execution time: 635 nanoseconds. + Weight::from_ref_time(914_996 as u64) + // Standard Error: 611 + .saturating_add(Weight::from_ref_time(735_020 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotl(r: u32, ) -> Weight { - // Minimum execution time: 621 nanoseconds. - Weight::from_ref_time(933_845 as u64) - // Standard Error: 194 - .saturating_add(Weight::from_ref_time(736_788 as u64).saturating_mul(r as u64)) + // Minimum execution time: 663 nanoseconds. + Weight::from_ref_time(914_333 as u64) + // Standard Error: 169 + .saturating_add(Weight::from_ref_time(734_033 as u64).saturating_mul(r as u64)) } /// The range of component `r` is `[0, 50]`. fn instr_i64rotr(r: u32, ) -> Weight { - // Minimum execution time: 640 nanoseconds. - Weight::from_ref_time(932_522 as u64) - // Standard Error: 262 - .saturating_add(Weight::from_ref_time(736_535 as u64).saturating_mul(r as u64)) + // Minimum execution time: 631 nanoseconds. + Weight::from_ref_time(916_503 as u64) + // Standard Error: 224 + .saturating_add(Weight::from_ref_time(736_168 as u64).saturating_mul(r as u64)) } } From 8dcab8f80e1122be30da81a23de026f50b1c6828 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Tue, 22 Nov 2022 13:57:12 +0100 Subject: [PATCH 22/27] Fix docs as suggested by code review --- frame/contracts/src/wasm/mod.rs | 5 +++++ frame/contracts/src/wasm/prepare.rs | 8 ++++---- frame/contracts/src/wasm/runtime.rs | 4 ++-- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 844862bf22b1a..0e220acab0d47 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -193,6 +193,11 @@ where } } + /// Crates and returns an instance of the supplied code. + /// + /// This is either used for later executing a contract or for validation of a contract. + /// When validating we pass `()` as `host_state`. Please note that such a dummy instance must + /// **never** be called executed since it will panic the executor. pub fn instantiate( code: &[u8], host_state: H, diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 92aa7e1fc7f2c..2fad4bf8b139f 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -469,10 +469,10 @@ where /// /// The checks are: /// -/// - provided code is a valid wasm module. -/// - the module doesn't define an internal memory instance, -/// - imported memory (if any) doesn't reserve more memory than permitted by the `schedule`, -/// - all imported functions from the external environment matches defined by `env` module, +/// - the provided code is a valid wasm module +/// - the module doesn't define an internal memory instance +/// - imported memory (if any) doesn't reserve more memory than permitted by the `schedule` +/// - all imported functions from the external environment matches defined by `env` module /// /// The preprocessing includes injecting code for gas metering and metering the height of stack. pub fn prepare( diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 37ff68d7107fa..4c6006d2612fe 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -263,10 +263,10 @@ pub enum RuntimeCosts { SetCodeHash, /// Weight of calling `ecdsa_to_eth_address` EcdsaToEthAddress, - /// Weight of calling `seal_reentrance_count` + /// Weight of calling `reentrance_count` #[cfg(feature = "unstable-interface")] ReentrantCount, - /// Weight of calling `seal_account_reentrance_count` + /// Weight of calling `account_reentrance_count` #[cfg(feature = "unstable-interface")] AccountEntranceCount, } From a79fc1a0758ba2780f08a0b68ce7614ebc07fd50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Tue, 22 Nov 2022 15:26:37 +0100 Subject: [PATCH 23/27] Improve docs for `CodeRejected` --- frame/contracts/src/lib.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs index da0a09d263623..00b0655ea4af6 100644 --- a/frame/contracts/src/lib.rs +++ b/frame/contracts/src/lib.rs @@ -830,8 +830,13 @@ pub mod pallet { /// to determine whether a reversion has taken place. ContractReverted, /// The contract's code was found to be invalid during validation or instrumentation. + /// + /// The most likely cause of this is that an API was used which is not supported by the + /// node. This hapens if an older node is used with a new version of ink!. Try updating + /// your node to the newest available version. + /// /// A more detailed error can be found on the node console if debug messages are enabled - /// or in the debug buffer which is returned to RPC clients. + /// by supplying `-lruntime::contracts=debug`. CodeRejected, /// An indetermistic code was used in a context where this is not permitted. Indeterministic, From 442917e335e3f29e012fb9b2956cd3a250435e43 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Tue, 22 Nov 2022 16:52:58 +0100 Subject: [PATCH 24/27] Apply suggestions from code review Co-authored-by: Sasha Gryaznov --- frame/contracts/src/wasm/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 0e220acab0d47..caa1827fbf04c 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -193,11 +193,11 @@ where } } - /// Crates and returns an instance of the supplied code. + /// Creates and returns an instance of the supplied code. /// /// This is either used for later executing a contract or for validation of a contract. /// When validating we pass `()` as `host_state`. Please note that such a dummy instance must - /// **never** be called executed since it will panic the executor. + /// **never** be called/executed since it will panic the executor. pub fn instantiate( code: &[u8], host_state: H, From 4b10d3fdca68201deeef96402bdfd270f105270b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 24 Nov 2022 16:38:46 +0100 Subject: [PATCH 25/27] Fix logic bug when setting `deterministic_only` --- frame/contracts/src/wasm/prepare.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frame/contracts/src/wasm/prepare.rs b/frame/contracts/src/wasm/prepare.rs index 2fad4bf8b139f..fb5ae1229078f 100644 --- a/frame/contracts/src/wasm/prepare.rs +++ b/frame/contracts/src/wasm/prepare.rs @@ -401,7 +401,7 @@ where // This is not our only defense: We check for float types later in the preparation // process. Additionally, all instructions explictily need to have weights assigned // or the deployment will fail. We have none assigned for float instructions. - deterministic_only: matches!(determinism, Determinism::AllowIndeterminism), + deterministic_only: matches!(determinism, Determinism::Deterministic), mutable_global: false, saturating_float_to_int: false, sign_extension: false, From 631d6df9900515fc53e7acdec1e83d59336aea1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 24 Nov 2022 16:41:17 +0100 Subject: [PATCH 26/27] Don't panic when module fails to compile --- frame/contracts/src/wasm/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index caa1827fbf04c..86bc377b81307 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -215,7 +215,7 @@ where .wasm_sign_extension(false) .wasm_saturating_float_to_int(false); let engine = Engine::new(&config); - let module = Module::new(&engine, code).unwrap(); + let module = Module::new(&engine, code)?; let mut store = Store::new(&engine, host_state); let mut linker = Linker::new(); E::define(&mut store, &mut linker)?; From d39f08588113b5e8dbd9a3f9671c4dc69c10aaf8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= Date: Thu, 24 Nov 2022 16:58:31 +0100 Subject: [PATCH 27/27] Apply suggestions from code review Co-authored-by: Robin Freyler --- frame/contracts/proc-macro/src/lib.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/frame/contracts/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs index c94b0d94224ed..399a1b413f121 100644 --- a/frame/contracts/proc-macro/src/lib.rs +++ b/frame/contracts/proc-macro/src/lib.rs @@ -172,7 +172,7 @@ impl HostFnReturn { Self::U32 | Self::ReturnCode => quote! { ::core::primitive::u32 }, }; quote! { - Result<#ok, ::wasmi::core::Trap> + ::core::result::Result<#ok, ::wasmi::core::Trap> } } } @@ -389,8 +389,8 @@ fn expand_impls(def: &mut EnvDef) -> TokenStream2 { impl<'a, E> crate::wasm::Environment> for Env where E: Ext, - ::AccountId: - sp_core::crypto::UncheckedFrom<::Hash> + AsRef<[u8]>, + ::AccountId: + ::sp_core::crypto::UncheckedFrom<::Hash> + ::core::convert::AsRef<[::core::primitive::u8]>, { fn define(store: &mut ::wasmi::Store>, linker: &mut ::wasmi::Linker>) -> Result<(), ::wasmi::errors::LinkerError> { #impls @@ -474,7 +474,7 @@ fn expand_functions( let mut func = #inner; func() .map_err(#map_err) - .map(Into::into) + .map(::core::convert::Into::into) }))?; } });