From 928ee2b353a5b7207c01e7aacf69ef433ebea931 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexander=20Thei=C3=9Fen?= <alex.theissen@me.com>
Date: Thu, 24 Nov 2022 23:51:36 +0100
Subject: [PATCH] contracts: Replace `sp-sandbox` and `wasmi-validation` by
newest wasmi (#12501)
* Replace sp-sandbox and wasmi-validation by just wasmi
* ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts
* Re-check original code on re-instrumentation
* Fix clippy
* ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts
* Apply suggestions from code review
Co-authored-by: Robin Freyler <robin.freyler@gmail.com>
* Replace wasmi by ::wasmi
* Bump wasmi to 0.20
* Add explanation for `unreachable`
* Change proof
* Fixup master merge
* ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts
* Fixup naming inconsistencies introduced by reentrancy PR
* Fix `scan_imports` docs
* Apply suggestions from code review
Co-authored-by: Sasha Gryaznov <hi@agryaznov.com>
* Fixup suggestions
* Remove unnecessary &mut
* Fix test
* ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts
* Fix benchmark merge fail
* ".git/.scripts/bench-bot.sh" pallet dev pallet_contracts
* Fix docs as suggested by code review
* Improve docs for `CodeRejected`
* Apply suggestions from code review
Co-authored-by: Sasha Gryaznov <hi@agryaznov.com>
* Fix logic bug when setting `deterministic_only`
* Don't panic when module fails to compile
* Apply suggestions from code review
Co-authored-by: Robin Freyler <robin.freyler@gmail.com>
Co-authored-by: command-bot <>
Co-authored-by: Robin Freyler <robin.freyler@gmail.com>
Co-authored-by: Sasha Gryaznov <hi@agryaznov.com>
---
Cargo.lock | 70 +-
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 +
...unt_call.wat => reentrance_count_call.wat} | 14 +-
...at => reentrance_count_delegated_call.wat} | 6 +-
frame/contracts/proc-macro/src/lib.rs | 326 ++-
frame/contracts/src/benchmarking/code.rs | 16 +-
frame/contracts/src/benchmarking/mod.rs | 17 +-
frame/contracts/src/benchmarking/sandbox.rs | 41 +-
frame/contracts/src/chain_extension.rs | 30 +-
frame/contracts/src/exec.rs | 4 +-
frame/contracts/src/lib.rs | 20 +-
frame/contracts/src/schedule.rs | 8 +-
frame/contracts/src/tests.rs | 48 +-
frame/contracts/src/wasm/code_cache.rs | 14 +-
frame/contracts/src/wasm/env_def/mod.rs | 83 -
frame/contracts/src/wasm/mod.rs | 138 +-
frame/contracts/src/wasm/prepare.rs | 255 ++-
frame/contracts/src/wasm/runtime.rs | 554 +++--
frame/contracts/src/weights.rs | 1869 +++++++++--------
23 files changed, 1909 insertions(+), 1634 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
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%)
delete mode 100644 frame/contracts/src/wasm/env_def/mod.rs
diff --git a/Cargo.lock b/Cargo.lock
index ca0ebee0ac475..a8c21b9830eea 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3099,6 +3099,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"
@@ -5317,10 +5323,10 @@ dependencies = [
"sp-io",
"sp-keystore",
"sp-runtime",
- "sp-sandbox",
"sp-std",
"wasm-instrument",
- "wasmi-validation",
+ "wasmi 0.20.0",
+ "wasmparser-nostd",
"wat",
]
@@ -7320,7 +7326,7 @@ dependencies = [
"cc",
"libc",
"once_cell",
- "spin",
+ "spin 0.5.2",
"untrusted",
"web-sys",
"winapi",
@@ -8008,7 +8014,7 @@ dependencies = [
"tempfile",
"tracing",
"tracing-subscriber",
- "wasmi",
+ "wasmi 0.13.0",
"wat",
]
@@ -8025,7 +8031,7 @@ dependencies = [
"thiserror",
"wasm-instrument",
"wasmer",
- "wasmi",
+ "wasmi 0.13.0",
]
[[package]]
@@ -8039,7 +8045,7 @@ dependencies = [
"sp-runtime-interface",
"sp-sandbox",
"sp-wasm-interface",
- "wasmi",
+ "wasmi 0.13.0",
]
[[package]]
@@ -9564,7 +9570,7 @@ dependencies = [
"substrate-bip39",
"thiserror",
"tiny-bip39",
- "wasmi",
+ "wasmi 0.13.0",
"zeroize",
]
@@ -9895,7 +9901,7 @@ dependencies = [
"sp-io",
"sp-std",
"sp-wasm-interface",
- "wasmi",
+ "wasmi 0.13.0",
"wat",
]
@@ -10095,7 +10101,7 @@ dependencies = [
"log",
"parity-scale-codec",
"sp-std",
- "wasmi",
+ "wasmi 0.13.0",
"wasmtime",
]
@@ -10120,6 +10126,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.6.0"
@@ -11624,7 +11636,19 @@ checksum = "fc13b3c219ca9aafeec59150d80d89851df02e0061bc357b4d66fc55a8d38787"
dependencies = [
"parity-wasm",
"wasmi-validation",
- "wasmi_core",
+ "wasmi_core 0.2.0",
+]
+
+[[package]]
+name = "wasmi"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01bf50edb2ea9d922aa75a7bf3c15e26a6c9e2d18c56e862b49737a582901729"
+dependencies = [
+ "spin 0.9.4",
+ "wasmi_arena",
+ "wasmi_core 0.5.0",
+ "wasmparser-nostd",
]
[[package]]
@@ -11636,6 +11660,12 @@ dependencies = [
"parity-wasm",
]
+[[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"
@@ -11649,6 +11679,17 @@ dependencies = [
"num-traits",
]
+[[package]]
+name = "wasmi_core"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5bf998ab792be85e20e771fe14182b4295571ad1d4f89d3da521c1bef5f597a"
+dependencies = [
+ "downcast-rs",
+ "libm",
+ "num-traits",
+]
+
[[package]]
name = "wasmparser"
version = "0.78.2"
@@ -11664,6 +11705,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 6c892a00f5323..cf9889ac0be77 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.20", 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 = "7.0.0", default-features = false, path = "../../primitives/core" }
sp-io = { version = "7.0.0", default-features = false, path = "../../primitives/io" }
sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
-sp-sandbox = { version = "0.10.0-dev", default-features = false, path = "../../primitives/sandbox" }
sp-std = { version = "5.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/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/proc-macro/src/lib.rs b/frame/contracts/proc-macro/src/lib.rs
index 648bf0fd1f812..399a1b413f121 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! { ::core::primitive::u32 },
+ };
+ quote! {
+ ::core::result::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(<u8>)] 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)
+ // 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
+ .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<ReturnCode, TrapReason>,
- Result<u32, TrapReason>"#;
-
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![ <u32>::VALUE_TYPE ] },
- HostFnReturn::ReturnCode => quote! { vec![ <ReturnCode>::VALUE_TYPE ] },
- HostFnReturn::Unit => quote! { vec![] },
- };
-
- quote! {
- wasm_instrument::parity_wasm::elements::FunctionType::new(
- vec! [ #(<#args>::VALUE_TYPE),* ],
- #returns,
- )
- }
- }
}
impl EnvDef {
@@ -343,149 +351,135 @@ 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 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<E> });
+ let dummy_impls = expand_functions(def, false, quote! { () });
+
+ quote! {
+ impl<'a, E> crate::wasm::Environment<crate::wasm::runtime::Runtime<'a, E>> for Env
+ where
+ E: Ext,
+ <E::T as ::frame_system::Config>::AccountId:
+ ::sp_core::crypto::UncheckedFrom<<E::T as ::frame_system::Config>::Hash> + ::core::convert::AsRef<[::core::primitive::u8]>,
+ {
+ fn define(store: &mut ::wasmi::Store<crate::wasm::Runtime<E>>, linker: &mut ::wasmi::Linker<crate::wasm::Runtime<E>>) -> 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 {
+ // This is part of the implementation for `Environment<()>` which is not
+ // meant to be actually executed. It is only for validation which will
+ // never call host functions.
+ ::core::unreachable!()
+ } }
+ };
+ let 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<E: Ext>(
- ctx: &mut crate::wasm::Runtime<E>,
- args: &[sp_sandbox::Value],
- ) -> Result<sp_sandbox::ReturnValue, sp_sandbox::HostError>
- where
- <E::T as frame_system::Config>::AccountId: sp_core::crypto::UncheckedFrom<<E::T as frame_system::Config>::Hash>
- + AsRef<[u8]>,
- {
- #[allow(unused)]
- let mut args = args.iter();
- let mut body = || {
- #( #params )*
- #body
- };
- #outline
+ } else {
+ quote! {
+ |reason| { reason }
}
- #ident::<E>
- });
- }
- });
+ };
+ let allow_unused = if expand_blocks {
+ quote! { }
+ } else {
+ quote! { #[allow(unused_variables)] }
+ };
- let packed_impls = quote! {
- #( #impls )*
- };
- quote! {
- impl<E: Ext> crate::wasm::env_def::FunctionImplProvider<E> for Env
- where
- <E::T as frame_system::Config>::AccountId:
- sp_core::crypto::UncheckedFrom<<E::T as frame_system::Config>::Hash> + AsRef<[u8]>,
- {
- fn impls<F: FnMut(&[u8], &[u8], crate::wasm::env_def::HostFunc<E>)>(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(::core::convert::Into::into)
+ }))?;
}
+ });
+ quote! {
+ #( #impls )*
}
}
@@ -502,7 +496,7 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream {
/// ```nocompile
/// #[define_env]
/// pub mod some_env {
-/// fn some_host_fn(ctx: Runtime<E>, 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 +511,12 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream {
/// #[define_env]
/// pub mod some_env {
/// #[version(1)]
-/// fn some_host_fn(ctx: Runtime<E>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
+/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
/// }
///
/// #[unstable]
-/// fn some_host_fn(ctx: Runtime<E>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
+/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
/// }
/// }
@@ -540,12 +534,12 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream {
/// pub mod some_env {
/// #[version(1)]
/// #[prefixed_alias]
-/// fn some_host_fn(ctx: Runtime<E>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
+/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
/// }
///
/// #[unstable]
-/// fn some_host_fn(ctx: Runtime<E>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
+/// fn some_host_fn(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
/// }
/// }
@@ -562,16 +556,16 @@ fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream {
/// - `Result<u32, TrapReason>`.
///
/// 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<Runtime<E>> 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<T: Config> {
pub code: Vec<u8>,
pub hash: <T::Hashing as Hash>::Output,
- memory: Option<ImportedMemory>,
+ pub memory: Option<ImportedMemory>,
}
impl<T: Config> From<ModuleDefinition> for WasmModule<T>
@@ -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<S>(&self, env: &mut EnvironmentDefinitionBuilder<S>) -> Option<Memory> {
- 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 539f4b2cf737b..2494a4cbebd55 100644
--- a/frame/contracts/src/benchmarking/mod.rs
+++ b/frame/contracts/src/benchmarking/mod.rs
@@ -425,7 +425,7 @@ benchmarks! {
.map(|n| account::<T::AccountId>("account", n, 0))
.collect::<Vec<_>>();
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::<Vec<_>>();
+ let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::<Vec<_>>();
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
@@ -462,7 +462,7 @@ benchmarks! {
.map(|n| account::<T::AccountId>("account", n, 0))
.collect::<Vec<_>>();
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::<Vec<_>>();
+ let accounts_bytes = accounts.iter().flat_map(|a| a.encode()).collect::<Vec<_>>();
let accounts_len = accounts_bytes.len();
let pages = code::max_pages::<T>();
let code = WasmModule::<T>::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::<Vec<_>>();
let pub_keys_bytes_len = pub_keys_bytes.len() as i32;
let code = WasmModule::<T>::from(ModuleDefinition {
@@ -2086,13 +2085,13 @@ benchmarks! {
let origin = RawOrigin::Signed(instance.caller.clone());
}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
- reentrant_count {
+ seal_reentrance_count {
let r in 0 .. API_BENCHMARK_BATCHES;
let code = WasmModule::<T>::from(ModuleDefinition {
memory: Some(ImportedMemory::max::<T>()),
imported_functions: vec![ImportedFunction {
module: "__unstable__",
- name: "reentrant_count",
+ name: "reentrance_count",
params: vec![],
return_type: Some(ValueType::I32),
}],
@@ -2106,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::<T>::dummy_with_bytes(0);
let accounts = (0..r * API_BENCHMARK_BATCH_SIZE)
@@ -2921,7 +2920,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<T>) = ([0x9b, 0xae, 0x9d, 0x5e], 1000u32.into());
@@ -2959,7 +2958,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::<T::AccountId>("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<Memory>,
+ 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<T>) -> 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::<T>::instantiate::<EmptyEnv, _>(
+ &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<Vec<u8>> {
- 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<T: Decode + MaxEncodedLen>(&mut self) -> Result<T> {
- 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<T: Decode>(&mut self, len: u32) -> Result<T> {
- 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<Weight>,
) -> 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/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::T> = &self.top_frame().account_id;
self.account_reentrance_count(id).saturating_sub(1)
}
diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs
index 52fb0190ba3a9..00b0655ea4af6 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};
@@ -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,
@@ -1009,8 +1014,14 @@ where
determinism: Determinism,
) -> CodeUploadResult<CodeHash<T>, BalanceOf<T>> {
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, <Error<T>>::StorageDepositLimitExhausted);
@@ -1135,6 +1146,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/schedule.rs b/frame/contracts/src/schedule.rs
index 52cb7698d6952..79f9f49e58190 100644
--- a/frame/contracts/src/schedule.rs
+++ b/frame/contracts/src/schedule.rs
@@ -423,8 +423,8 @@ pub struct HostFnWeights<T: Config> {
/// 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,
@@ -538,7 +538,7 @@ impl<T: Config> Default for InstructionWeights<T> {
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),
@@ -665,7 +665,7 @@ impl<T: Config> Default for HostFnWeights<T> {
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 7054ceb07a6fc..e7b27ed38e271 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::<Test>("return_from_start_fn").unwrap();
+ let (wasm, code_hash) = compile_module::<Test>("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::<Test>("invalid_import").unwrap();
ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
+ let (wasm, _) = compile_module::<Test>("invalid_module").unwrap();
+ assert_noop!(
+ Contracts::upload_code(
+ RuntimeOrigin::signed(ALICE),
+ wasm.clone(),
+ None,
+ Determinism::Deterministic
+ ),
+ <Error<Test>>::CodeRejected,
+ );
+ let result = Contracts::bare_instantiate(
+ ALICE,
+ 0,
+ GAS_LIMIT,
+ None,
+ Code::Upload(wasm),
+ vec![],
+ vec![],
+ true,
+ );
+ assert_err!(result.result, <Error<Test>>::CodeRejected);
+ assert_eq!(
+ std::str::from_utf8(&result.debug_message).unwrap(),
+ "validation of new code failed"
+ );
+
+ let (wasm, _) = compile_module::<Test>("invalid_contract").unwrap();
assert_noop!(
Contracts::upload_code(
RuntimeOrigin::signed(ALICE),
@@ -3747,7 +3773,7 @@ fn code_rejected_error_works() {
assert_err!(result.result, <Error<Test>>::CodeRejected);
assert_eq!(
std::str::from_utf8(&result.debug_message).unwrap(),
- "module imports a non-existent function"
+ "call function isn't exported"
);
});
}
@@ -4386,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::<Test>("reentrant_count_call").unwrap();
+fn reentrance_count_works_with_call() {
+ let (wasm, code_hash) = compile_module::<Test>("reentrance_count_call").unwrap();
let contract_addr = Contracts::contract_address(&ALICE, &code_hash, &[]);
ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
@@ -4423,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::<Test>("reentrant_count_delegated_call").unwrap();
+fn reentrance_count_works_with_delegated_call() {
+ let (wasm, code_hash) = compile_module::<Test>("reentrance_count_delegated_call").unwrap();
let contract_addr = Contracts::contract_address(&ALICE, &code_hash, &[]);
ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
@@ -4462,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::<Test>("account_reentrance_count_call").unwrap();
- let (wasm_reentrant_count, code_hash_reentrant_count) =
- compile_module::<Test>("reentrant_count_call").unwrap();
+ let (wasm_reentrance_count, code_hash_reentrance_count) =
+ compile_module::<Test>("reentrance_count_call").unwrap();
ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
@@ -4483,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/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<T: Config>(
prefab_module: &mut PrefabWasmModule<T>,
schedule: &Schedule<T>,
-) -> Result<u32, DispatchError> {
+) -> Result<u32, DispatchError>
+where
+ T::AccountId: UncheckedFrom<T::Hash> + AsRef<[u8]>,
+{
let original_code =
<PristineCode<T>>::get(&prefab_module.code_hash).ok_or(Error::<T>::CodeNotFound)?;
let original_code_len = original_code.len();
@@ -201,9 +204,12 @@ pub fn reinstrument<T: Config>(
// 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::<T>(&original_code, schedule, prefab_module.determinism)
- .map_err(|_| <Error<T>>::CodeRejected)?,
- Some("Contract exceeds limit after re-instrumentation."),
+ prepare::reinstrument::<super::runtime::Env, T>(
+ &original_code,
+ schedule,
+ prefab_module.determinism,
+ )?,
+ Some("Contract exceeds size limit after re-instrumentation."),
);
prefab_module.instruction_weights_version = schedule.instruction_weights.version;
<CodeStorage<T>>::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<Self>;
-}
-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<Self> {
- 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<Self> {
- 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<Self> {
- match v {
- Value::I64(v) => Some(v as u64),
- _ => None,
- }
- }
-}
-
-pub type HostFunc<E> = fn(
- &mut Runtime<E>,
- &[sp_sandbox::Value],
-) -> Result<sp_sandbox::ReturnValue, sp_sandbox::HostError>;
-
-pub trait FunctionImplProvider<E: Ext> {
- fn impls<F: FnMut(&[u8], &[u8], HostFunc<E>)>(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 ba0a0abf11302..86bc377b81307 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<T>,
owner: AccountIdOf<T>,
determinism: Determinism,
+ try_instantiate: TryInstantiate,
) -> Result<Self, (DispatchError, &'static str)> {
- let module = prepare::prepare_contract(
+ let module = prepare::prepare::<runtime::Env, T>(
original_code.try_into().map_err(|_| (<Error<T>>::CodeTooLarge.into(), ""))?,
schedule,
owner,
determinism,
+ try_instantiate,
)?;
Ok(module)
}
@@ -189,6 +193,44 @@ where
}
}
+ /// 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.
+ pub fn instantiate<E, H>(
+ code: &[u8],
+ host_state: H,
+ memory: (u32, u32),
+ stack_limits: StackLimits,
+ ) -> Result<(Store<H>, Memory, Instance), wasmi::Error>
+ where
+ E: Environment<H>,
+ {
+ 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)?;
+ 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(
+ "The limits defined in our `Schedule` limit the amount of memory well below 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 +243,7 @@ where
schedule: &Schedule<T>,
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::<DispatchError, _>(Into::into)?;
code_cache::store(executable, false)
}
@@ -247,36 +289,35 @@ where
function: &ExportedFunction,
input_data: Vec<u8>,
) -> 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::<crate::wasm::runtime::Env, _>(
+ 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::<T>::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::<T>::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<T> {
@@ -307,7 +348,7 @@ mod tests {
};
use assert_matches::assert_matches;
use frame_support::{
- assert_ok,
+ assert_err, assert_ok,
dispatch::DispatchResultWithPostInfo,
weights::{OldWeight, Weight},
};
@@ -578,7 +619,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<Self::T>) -> u32 {
@@ -594,8 +635,9 @@ mod tests {
&schedule,
ALICE,
Determinism::Deterministic,
+ TryInstantiate::Skip,
)
- .unwrap();
+ .map_err(|err| err.0)?;
executable.execute(ext.borrow_mut(), &ExportedFunction::Call, input_data)
}
@@ -788,10 +830,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),
- <Error<Test>>::InputForwarded,
- );
+ assert_err!(execute(CODE, input.clone(), &mut mock_ext), <Error<Test>>::InputForwarded,);
assert_eq!(
&mock_ext.calls,
@@ -1584,35 +1623,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, <Error<Test>>::CodeRejected,);
}
const CODE_TIMESTAMP_NOW: &str = r#"
@@ -2859,10 +2895,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
@@ -2875,7 +2911,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/prepare.rs b/frame/contracts/src/wasm/prepare.rs
index 3e6b9eee96680..fb5ae1229078f 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 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.
+ Instantiate,
+ /// 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
+ /// 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<T>) -> Result<Self, &'static str> {
- 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::<PlainValidator>(&module, ()).map_err(|_| "Module is not valid")?;
-
// Return a `ContractModule` instance with
// __valid__ module.
Ok(ContractModule { module, schedule })
@@ -279,27 +292,33 @@ 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<C: ImportSatisfyCheck>(
+ fn scan_imports(
&self,
import_fn_banlist: &[&[u8]],
) -> Result<Option<&MemoryType>, &'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 +332,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,12 +369,54 @@ fn get_memory_limits<T: Config>(
}
}
-fn check_and_instrument<C: ImportSatisfyCheck, T: Config>(
+/// Check and instrument the given `original_code`.
+///
+/// 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<E, T>(
original_code: &[u8],
schedule: &Schedule<T>,
determinism: Determinism,
-) -> Result<(Vec<u8>, (u32, u32)), &'static str> {
- let result = (|| {
+ try_instantiate: TryInstantiate,
+) -> Result<(Vec<u8>, (u32, u32)), (DispatchError, &'static str)>
+where
+ E: Environment<()>,
+ T: Config,
+ T::AccountId: UncheckedFrom<T::Hash> + 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::Deterministic),
+ 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)
+ .map_err(|err| {
+ log::debug!(target: "runtime::contracts", "{}", err);
+ (Error::<T>::CodeRejected.into(), "validation of new code failed")
+ })?;
+
+ let (code, (initial, maximum)) = (|| {
let contract_module = ContractModule::new(original_code, schedule)?;
contract_module.scan_exports()?;
contract_module.ensure_no_internal_memory()?;
@@ -387,7 +432,7 @@ fn check_and_instrument<C: ImportSatisfyCheck, T: Config>(
// 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::<C>(&disallowed_imports)?, schedule)?;
+ get_memory_limits(contract_module.scan_imports(&disallowed_imports)?, schedule)?;
let code = contract_module
.inject_gas_metering(determinism)?
@@ -395,24 +440,56 @@ fn check_and_instrument<C: ImportSatisfyCheck, T: Config>(
.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::<T>::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::<T>::instantiate::<E, _>(&code, (), (initial, maximum), stack_limits)
+ .map_err(|err| {
+ log::debug!(target: "runtime::contracts", "{}", err);
+ (Error::<T>::CodeRejected.into(), "new code rejected after instrumentation")
+ })?;
}
- result
+ Ok((code, (initial, maximum)))
}
-fn do_preparation<C: ImportSatisfyCheck, T: Config>(
+/// Loads the given module given in `original_code`, performs some checks on it and
+/// does some preprocessing.
+///
+/// The checks are:
+///
+/// - 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<E, T>(
original_code: CodeVec<T>,
schedule: &Schedule<T>,
owner: AccountIdOf<T>,
determinism: Determinism,
-) -> Result<PrefabWasmModule<T>, (DispatchError, &'static str)> {
+ try_instantiate: TryInstantiate,
+) -> Result<PrefabWasmModule<T>, (DispatchError, &'static str)>
+where
+ E: Environment<()>,
+ T: Config,
+ T::AccountId: UncheckedFrom<T::Hash> + AsRef<[u8]>,
+{
let (code, (initial, maximum)) =
- check_and_instrument::<C, T>(original_code.as_ref(), schedule, determinism)
- .map_err(|msg| (<Error<T>>::CodeRejected.into(), msg))?;
+ instrument::<E, T>(original_code.as_ref(), schedule, determinism, try_instantiate)?;
+
let original_code_len = original_code.len();
let mut module = PrefabWasmModule {
@@ -420,10 +497,10 @@ fn do_preparation<C: ImportSatisfyCheck, T: Config>(
initial,
maximum,
code: code.try_into().map_err(|_| (<Error<T>>::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 +518,28 @@ fn do_preparation<C: ImportSatisfyCheck, T: Config>(
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<T: Config>(
- original_code: CodeVec<T>,
- schedule: &Schedule<T>,
- owner: AccountIdOf<T>,
- determinism: Determinism,
-) -> Result<PrefabWasmModule<T>, (DispatchError, &'static str)> {
- do_preparation::<super::runtime::Env, T>(original_code, schedule, owner, determinism)
-}
-
-/// The same as [`prepare_contract`] but without constructing a new [`PrefabWasmModule`]
-///
-/// # Note
+/// Same as [`prepare`] but without constructing a new module.
///
-/// Use this when an existing contract should be re-instrumented with a newer schedule version.
-pub fn reinstrument_contract<T: Config>(
+/// 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<E, T>(
original_code: &[u8],
schedule: &Schedule<T>,
determinism: Determinism,
-) -> Result<Vec<u8>, &'static str> {
- Ok(check_and_instrument::<super::runtime::Env, T>(original_code, schedule, determinism)?.0)
+) -> Result<Vec<u8>, DispatchError>
+where
+ E: Environment<()>,
+ T: Config,
+ T::AccountId: UncheckedFrom<T::Hash> + AsRef<[u8]>,
+{
+ instrument::<E, T>(original_code, schedule, determinism, TryInstantiate::Skip)
+ .map_err(|(err, msg)| {
+ log::error!(target: "runtime::contracts", "CodeRejected during reinstrument: {}", msg);
+ err
+ })
+ .map(|(code, _)| code)
}
/// Alternate (possibly unsafe) preparation functions used only for benchmarking.
@@ -482,29 +550,22 @@ pub fn reinstrument_contract<T: Config>(
/// 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<T: Config>(
+ pub fn prepare<T: Config>(
original_code: Vec<u8>,
schedule: &Schedule<T>,
owner: AccountIdOf<T>,
) -> Result<PrefabWasmModule<T>, &'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 +576,7 @@ pub mod benchmarking {
deposit: Default::default(),
refcount: 0,
}),
+ determinism: Determinism::Deterministic,
})
}
}
@@ -540,27 +602,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<E>) -> 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<E>, _amount: u32) -> Result<(), TrapReason> {
+ fn gas(_ctx: _, _memory: _, _amount: u64) -> Result<(), TrapReason> {
Ok(())
}
- fn nop(_ctx: crate::wasm::Runtime<E>, _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<E>, _unused: i32) -> Result<(), TrapReason> {
+ fn nop(_ctx: _, _memory: _, _unused: i32) -> Result<(), TrapReason> {
Ok(())
}
}
@@ -582,7 +645,13 @@ mod tests {
},
.. Default::default()
};
- let r = do_preparation::<env::Env, Test>(wasm, &schedule, ALICE, Determinism::Deterministic);
+ let r = prepare::<env::Env, Test>(
+ wasm,
+ &schedule,
+ ALICE,
+ Determinism::Deterministic,
+ TryInstantiate::Instantiate,
+ );
assert_matches::assert_matches!(r.map_err(|(_, msg)| msg), $($expected)*);
}
};
@@ -718,7 +787,7 @@ mod tests {
(func (export "deploy"))
)
"#,
- Err("Module is not valid")
+ Err("validation of new code failed")
);
prepare_test!(
@@ -784,7 +853,7 @@ mod tests {
(func (export "deploy"))
)
"#,
- Err("Module is not valid")
+ Err("validation of new code failed")
);
prepare_test!(
@@ -910,7 +979,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 +1034,7 @@ mod tests {
(func (export "deploy"))
)
"#,
- Err("module imports a non-existent function")
+ Err("module imports a banned function")
);
prepare_test!(
@@ -978,7 +1047,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 3dac03cac625b..4c6006d2612fe 100644
--- a/frame/contracts/src/wasm/runtime.rs
+++ b/frame/contracts/src/wasm/runtime.rs
@@ -21,25 +21,34 @@ 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`](pallet_contracts_proc_macro::define_env) macro for the
+/// emitted `Env` struct.
+pub trait Environment<HostState> {
+ /// Adds all declared functions to the supplied [`Linker`](wasmi::Linker) and
+ /// [`Store`](wasmi::Store).
+ fn define(
+ store: &mut Store<HostState>,
+ linker: &mut Linker<HostState>,
+ ) -> Result<(), LinkerError>;
+}
+
/// Type of a storage key.
#[allow(dead_code)]
enum KeyType {
@@ -104,19 +113,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<Self> {
- debug_assert!(false, "We will never receive a ReturnCode but only send it to wasm.");
- None
- }
-}
-
impl From<ExecReturnValue> for ReturnCode {
fn from(from: ExecReturnValue) -> Self {
if from.flags.contains(ReturnFlags::REVERT) {
@@ -127,7 +123,14 @@ impl From<ExecReturnValue> for ReturnCode {
}
}
+impl From<ReturnCode> 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 +145,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 +163,14 @@ impl<T: Into<DispatchError>> From<T> 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 {
@@ -251,10 +263,10 @@ pub enum RuntimeCosts {
SetCodeHash,
/// Weight of calling `ecdsa_to_eth_address`
EcdsaToEthAddress,
- /// Weight of calling `seal_reentrant_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,
}
@@ -337,7 +349,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,
};
@@ -452,8 +464,7 @@ fn already_charged(_: u32) -> Option<RuntimeCosts> {
pub struct Runtime<'a, E: Ext + 'a> {
ext: &'a mut E,
input_data: Option<Vec<u8>>,
- memory: sp_sandbox::default_executor::Memory,
- trap_reason: Option<TrapReason>,
+ memory: Option<Memory>,
chain_extension: Option<Box<<E::T as Config>::ChainExtension>>,
}
@@ -463,58 +474,56 @@ where
<E::T as frame_system::Config>::AccountId:
UncheckedFrom<<E::T as frame_system::Config>::Hash> + AsRef<[u8]>,
{
- pub fn new(
- ext: &'a mut E,
- input_data: Vec<u8>,
- memory: sp_sandbox::default_executor::Memory,
- ) -> Self {
+ pub fn new(ext: &'a mut E, input_data: Vec<u8>) -> 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<sp_sandbox::ReturnValue, sp_sandbox::Error>,
- ) -> 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::<E::T>::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<Memory> {
+ self.memory
+ }
+
+ pub fn set_memory(&mut self, memory: Memory) {
+ self.memory = Some(memory);
+ }
- // Check the exact type of the error.
+ /// 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::<E::T>::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::<E::T>::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::<E::T>::ContractTrapped.into()),
+ Err(_) => Err(Error::<E::T>::CodeRejected.into()),
}
}
@@ -526,15 +535,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.
@@ -556,12 +556,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<Vec<u8>, DispatchError> {
+ pub fn read_sandbox_memory(
+ &self,
+ memory: &[u8],
+ ptr: u32,
+ len: u32,
+ ) -> Result<Vec<u8>, DispatchError> {
ensure!(len <= self.ext.schedule().limits.max_memory_size(), Error::<E::T>::OutOfBounds);
let mut buf = vec![0u8; len as usize];
- self.memory
- .get(ptr, buf.as_mut_slice())
- .map_err(|_| Error::<E::T>::OutOfBounds)?;
+ self.read_sandbox_memory_into_buf(memory, ptr, buf.as_mut_slice())?;
Ok(buf)
}
@@ -572,10 +575,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::<E::T>::OutOfBounds.into())
+ let ptr = ptr as usize;
+ let bound_checked =
+ memory.get(ptr..ptr + buf.len()).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
+ buf.copy_from_slice(bound_checked);
+ Ok(())
}
/// Reads and decodes a type with a size fixed at compile time from contract memory.
@@ -586,10 +594,14 @@ where
/// contract callable function.
pub fn read_sandbox_memory_as<D: Decode + MaxEncodedLen>(
&self,
+ memory: &[u8],
ptr: u32,
) -> Result<D, DispatchError> {
- 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::<E::T>::OutOfBounds)?;
+ let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked)
.map_err(|_| DispatchError::from(Error::<E::T>::DecodingFailed))?;
Ok(decoded)
}
@@ -607,11 +619,14 @@ where
/// regard to the overall weight.
pub fn read_sandbox_memory_as_unbounded<D: Decode>(
&self,
+ memory: &[u8],
ptr: u32,
len: u32,
) -> Result<D, DispatchError> {
- 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::<E::T>::OutOfBounds)?;
+ let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked)
.map_err(|_| DispatchError::from(Error::<E::T>::DecodingFailed))?;
Ok(decoded)
}
@@ -637,6 +652,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],
@@ -648,7 +664,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::<E::T>::OutputBufferTooSmall.into())
@@ -658,12 +674,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::<E::T>::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.
@@ -671,8 +683,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::<E::T>::OutOfBounds.into())
+ fn write_sandbox_memory(
+ &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::<E::T>::OutOfBounds)?;
+ bound_checked.copy_from_slice(buf);
+ Ok(())
}
/// Computes the given hash function on the supplied input.
@@ -688,7 +709,8 @@ where
///
/// The `input` and `output` buffers may overlap.
fn compute_hash_on_intermediate_buffer<F, R>(
- &mut self,
+ &self,
+ memory: &mut [u8],
hash_fn: F,
input_ptr: u32,
input_len: u32,
@@ -699,11 +721,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(())
}
@@ -740,6 +762,7 @@ where
fn set_storage(
&mut self,
+ memory: &[u8],
key_type: KeyType,
key_ptr: u32,
value_ptr: u32,
@@ -751,8 +774,8 @@ where
if value_len > max_size {
return Err(Error::<E::T>::ValueTooLarge.into())
}
- let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
- let value = Some(self.read_sandbox_memory(value_ptr, value_len)?);
+ let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::<E::T>()?)?;
+ 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::<E::T>::DecodingFailed)?,
@@ -773,9 +796,14 @@ where
Ok(write_outcome.old_len_with_sentinel())
}
- fn clear_storage(&mut self, key_type: KeyType, key_ptr: u32) -> Result<u32, TrapReason> {
+ fn clear_storage(
+ &mut self,
+ memory: &[u8],
+ key_type: KeyType,
+ key_ptr: u32,
+ ) -> Result<u32, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::ClearStorage(self.ext.max_value_size()))?;
- let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
+ let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::<E::T>()?)?;
let outcome = match key_type {
KeyType::Fix => self.ext.set_storage(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
@@ -795,13 +823,14 @@ where
fn get_storage(
&mut self,
+ memory: &mut [u8],
key_type: KeyType,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::GetStorage(self.ext.max_value_size()))?;
- let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
+ let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::<E::T>()?)?;
let outcome = match key_type {
KeyType::Fix => self.ext.get_storage(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
@@ -813,7 +842,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));
@@ -821,9 +857,14 @@ where
}
}
- fn contains_storage(&mut self, key_type: KeyType, key_ptr: u32) -> Result<u32, TrapReason> {
+ fn contains_storage(
+ &mut self,
+ memory: &[u8],
+ key_type: KeyType,
+ key_ptr: u32,
+ ) -> Result<u32, TrapReason> {
let charged = self.charge_gas(RuntimeCosts::ContainsStorage(self.ext.max_value_size()))?;
- let key = self.read_sandbox_memory(key_ptr, key_type.len::<E::T>()?)?;
+ let key = self.read_sandbox_memory(memory, key_ptr, key_type.len::<E::T>()?)?;
let outcome = match key_type {
KeyType::Fix => self.ext.get_storage_size(
&FixSizedKey::try_from(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
@@ -839,6 +880,7 @@ where
fn call(
&mut self,
+ memory: &mut [u8],
flags: CallFlags,
call_type: CallType,
input_data_ptr: u32,
@@ -855,14 +897,15 @@ where
self.input_data.take().ok_or(Error::<E::T>::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: <<E as Ext>::T as frame_system::Config>::AccountId =
- self.read_sandbox_memory_as(callee_ptr)?;
- let value: BalanceOf<<E as Ext>::T> = self.read_sandbox_memory_as(value_ptr)?;
+ self.read_sandbox_memory_as(memory, callee_ptr)?;
+ let value: BalanceOf<<E as Ext>::T> =
+ self.read_sandbox_memory_as(memory, value_ptr)?;
if value > 0u32.into() {
self.charge_gas(RuntimeCosts::CallSurchargeTransfer)?;
}
@@ -878,7 +921,7 @@ where
if flags.contains(CallFlags::ALLOW_REENTRY) {
return Err(Error::<E::T>::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)
},
};
@@ -895,15 +938,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::<E>::exec_into_return_code(call_outcome)?)
}
fn instantiate(
&mut self,
+ memory: &mut [u8],
code_hash_ptr: u32,
gas: u64,
value_ptr: u32,
@@ -918,17 +967,19 @@ where
) -> Result<ReturnCode, TrapReason> {
let gas = Weight::from_ref_time(gas);
self.charge_gas(RuntimeCosts::InstantiateBase { input_data_len, salt_len })?;
- let value: BalanceOf<<E as Ext>::T> = self.read_sandbox_memory_as(value_ptr)?;
+ let value: BalanceOf<<E as Ext>::T> = self.read_sandbox_memory_as(memory, value_ptr)?;
if value > 0u32.into() {
self.charge_gas(RuntimeCosts::InstantiateSurchargeTransfer)?;
}
- let code_hash: CodeHash<<E as Ext>::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<<E as Ext>::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(),
@@ -936,17 +987,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::<E>::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: <<E as Ext>::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)
}
@@ -967,7 +1023,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<E>, amount: u64) -> Result<(), TrapReason> {
+ fn gas(ctx: _, _memory: _, amount: u64) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::MeteringBlock(amount))?;
Ok(())
}
@@ -978,12 +1034,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<E>,
+ 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.
@@ -1007,12 +1064,13 @@ pub mod env {
#[version(1)]
#[prefixed_alias]
fn set_storage(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
key_ptr: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
- 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.
@@ -1034,13 +1092,14 @@ pub mod env {
#[version(2)]
#[prefixed_alias]
fn set_storage(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
key_ptr: u32,
key_len: u32,
value_ptr: u32,
value_len: u32,
) -> Result<u32, TrapReason> {
- 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.
@@ -1048,8 +1107,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<E>, 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.
@@ -1065,8 +1124,8 @@ pub mod env {
/// `SENTINEL` is returned as a sentinel value.
#[version(1)]
#[prefixed_alias]
- fn clear_storage(ctx: Runtime<E>, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
- ctx.clear_storage(KeyType::Variable(key_len), key_ptr)
+ fn clear_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
+ ctx.clear_storage(memory, KeyType::Variable(key_len), key_ptr)
}
/// Retrieve the value under the given key from storage.
@@ -1086,12 +1145,13 @@ pub mod env {
/// `ReturnCode::KeyNotFound`
#[prefixed_alias]
fn get_storage(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
key_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
- 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.
@@ -1115,13 +1175,14 @@ pub mod env {
#[version(1)]
#[prefixed_alias]
fn get_storage(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
key_ptr: u32,
key_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
- 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.
@@ -1138,8 +1199,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<E>, key_ptr: u32) -> Result<u32, TrapReason> {
- ctx.contains_storage(KeyType::Fix, key_ptr)
+ fn contains_storage(ctx: _, memory: _, key_ptr: u32) -> Result<u32, TrapReason> {
+ ctx.contains_storage(memory, KeyType::Fix, key_ptr)
}
/// Checks whether there is a value stored under the given key.
@@ -1157,8 +1218,8 @@ pub mod env {
/// `SENTINEL` is returned as a sentinel value.
#[version(1)]
#[prefixed_alias]
- fn contains_storage(ctx: Runtime<E>, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
- ctx.contains_storage(KeyType::Variable(key_len), key_ptr)
+ fn contains_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
+ ctx.contains_storage(memory, KeyType::Variable(key_len), key_ptr)
}
/// Retrieve and remove the value under the given key from storage.
@@ -1177,21 +1238,22 @@ pub mod env {
#[unstable]
#[prefixed_alias]
fn take_storage(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
key_ptr: u32,
key_len: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
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::<E::T>::try_from(key).map_err(|_| Error::<E::T>::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));
@@ -1215,7 +1277,8 @@ pub mod env {
/// `ReturnCode::TransferFailed`
#[prefixed_alias]
fn transfer(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
account_ptr: u32,
_account_len: u32,
value_ptr: u32,
@@ -1223,8 +1286,8 @@ pub mod env {
) -> Result<ReturnCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::Transfer)?;
let callee: <<E as Ext>::T as frame_system::Config>::AccountId =
- ctx.read_sandbox_memory_as(account_ptr)?;
- let value: BalanceOf<<E as Ext>::T> = ctx.read_sandbox_memory_as(value_ptr)?;
+ ctx.read_sandbox_memory_as(memory, account_ptr)?;
+ let value: BalanceOf<<E as Ext>::T> = ctx.read_sandbox_memory_as(memory, value_ptr)?;
let result = ctx.ext.transfer(&callee, value);
match result {
Ok(()) => Ok(ReturnCode::Success),
@@ -1249,7 +1312,8 @@ pub mod env {
/// compatibility. Consider switching to the newest version of this function.
#[prefixed_alias]
fn call(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
callee_ptr: u32,
_callee_len: u32,
gas: u64,
@@ -1261,6 +1325,7 @@ pub mod env {
output_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
ctx.call(
+ memory,
CallFlags::ALLOW_REENTRY,
CallType::Call { callee_ptr, value_ptr, gas },
input_data_ptr,
@@ -1302,7 +1367,8 @@ pub mod env {
#[version(1)]
#[prefixed_alias]
fn call(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
flags: u32,
callee_ptr: u32,
gas: u64,
@@ -1313,6 +1379,7 @@ pub mod env {
output_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
ctx.call(
+ memory,
CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
CallType::Call { callee_ptr, value_ptr, gas },
input_data_ptr,
@@ -1348,7 +1415,8 @@ pub mod env {
/// `ReturnCode::CodeNotFound`
#[prefixed_alias]
fn delegate_call(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
flags: u32,
code_hash_ptr: u32,
input_data_ptr: u32,
@@ -1357,6 +1425,7 @@ pub mod env {
output_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
ctx.call(
+ memory,
CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
CallType::DelegateCall { code_hash_ptr },
input_data_ptr,
@@ -1380,7 +1449,8 @@ pub mod env {
/// compatibility. Consider switching to the newest version of this function.
#[prefixed_alias]
fn instantiate(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
code_hash_ptr: u32,
_code_hash_len: u32,
gas: u64,
@@ -1396,6 +1466,7 @@ pub mod env {
salt_len: u32,
) -> Result<ReturnCode, TrapReason> {
ctx.instantiate(
+ memory,
code_hash_ptr,
gas,
value_ptr,
@@ -1453,7 +1524,8 @@ pub mod env {
#[version(1)]
#[prefixed_alias]
fn instantiate(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
code_hash_ptr: u32,
gas: u64,
value_ptr: u32,
@@ -1467,6 +1539,7 @@ pub mod env {
salt_len: u32,
) -> Result<ReturnCode, TrapReason> {
ctx.instantiate(
+ memory,
code_hash_ptr,
gas,
value_ptr,
@@ -1495,11 +1568,12 @@ pub mod env {
/// compatibility. Consider switching to the newest version of this function.
#[prefixed_alias]
fn terminate(
- ctx: Runtime<E>,
+ 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.
@@ -1519,8 +1593,8 @@ pub mod env {
/// - The deletion queue is full.
#[version(1)]
#[prefixed_alias]
- fn terminate(ctx: Runtime<E>, 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.
@@ -1534,10 +1608,10 @@ pub mod env {
///
/// This function traps if the input was previously forwarded by a `seal_call`.
#[prefixed_alias]
- fn input(ctx: Runtime<E>, 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);
@@ -1565,7 +1639,8 @@ pub mod env {
///
/// Using a reserved bit triggers a trap.
fn seal_return(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
flags: u32,
data_ptr: u32,
data_len: u32,
@@ -1573,7 +1648,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)?,
}))
}
@@ -1588,9 +1663,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<E>, 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(),
@@ -1608,10 +1684,10 @@ pub mod env {
///
/// Returned value is a u32-encoded boolean: (0 = false, 1 = true).
#[prefixed_alias]
- fn is_contract(ctx: Runtime<E>, account_ptr: u32) -> Result<u32, TrapReason> {
+ fn is_contract(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::IsContract)?;
let address: <<E as Ext>::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)
}
@@ -1631,16 +1707,18 @@ pub mod env {
/// `ReturnCode::KeyNotFound`
#[prefixed_alias]
fn code_hash(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
account_ptr: u32,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::CodeHash)?;
let address: <<E as Ext>::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(),
@@ -1661,10 +1739,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<E>, 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,
@@ -1684,7 +1763,7 @@ pub mod env {
///
/// Returned value is a u32-encoded boolean: (0 = false, 1 = true).
#[prefixed_alias]
- fn caller_is_origin(ctx: Runtime<E>) -> Result<u32, TrapReason> {
+ fn caller_is_origin(ctx: _, _memory: _) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::CallerIsOrigin)?;
Ok(ctx.ext.caller_is_origin() as u32)
}
@@ -1696,9 +1775,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<E>, 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(),
@@ -1722,7 +1802,8 @@ pub mod env {
/// gas can be smaller than one.
#[prefixed_alias]
fn weight_to_fee(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
gas: u64,
out_ptr: u32,
out_len_ptr: u32,
@@ -1730,6 +1811,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(),
@@ -1747,10 +1829,17 @@ pub mod env {
///
/// The data is encoded as Gas.
#[prefixed_alias]
- fn gas_left(ctx: Runtime<E>, 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.
@@ -1762,9 +1851,10 @@ pub mod env {
///
/// The data is encoded as T::Balance.
#[prefixed_alias]
- fn balance(ctx: Runtime<E>, 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(),
@@ -1783,12 +1873,14 @@ pub mod env {
/// The data is encoded as T::Balance.
#[prefixed_alias]
fn value_transferred(
- ctx: Runtime<E>,
+ 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(),
@@ -1811,7 +1903,8 @@ pub mod env {
/// This function is deprecated. Users should migrate to the version in the "seal1" module.
#[prefixed_alias]
fn random(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
subject_ptr: u32,
subject_len: u32,
out_ptr: u32,
@@ -1821,8 +1914,9 @@ pub mod env {
if subject_len > ctx.ext.schedule().limits.subject_len {
return Err(Error::<E::T>::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(),
@@ -1855,7 +1949,8 @@ pub mod env {
#[version(1)]
#[prefixed_alias]
fn random(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
subject_ptr: u32,
subject_len: u32,
out_ptr: u32,
@@ -1865,8 +1960,9 @@ pub mod env {
if subject_len > ctx.ext.schedule().limits.subject_len {
return Err(Error::<E::T>::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(),
@@ -1882,9 +1978,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<E>, 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(),
@@ -1897,9 +1994,15 @@ pub mod env {
///
/// The data is encoded as T::Balance.
#[prefixed_alias]
- fn minimum_balance(ctx: Runtime<E>, 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(),
@@ -1920,13 +2023,21 @@ pub mod env {
/// There is no longer a tombstone deposit. This function always returns 0.
#[prefixed_alias]
fn tombstone_deposit(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
out_ptr: u32,
out_len_ptr: u32,
) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::Balance)?;
let deposit = <BalanceOf<E::T>>::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.
@@ -1937,7 +2048,8 @@ pub mod env {
/// backwards compatiblity
#[prefixed_alias]
fn restore_to(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
_dest_ptr: u32,
_dest_len: u32,
_code_hash_ptr: u32,
@@ -1960,7 +2072,8 @@ pub mod env {
#[version(1)]
#[prefixed_alias]
fn restore_to(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
_dest_ptr: u32,
_code_hash_ptr: u32,
_rent_allowance_ptr: u32,
@@ -1981,7 +2094,8 @@ pub mod env {
/// - data_len - the length of the data buffer.
#[prefixed_alias]
fn deposit_event(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
topics_ptr: u32,
topics_len: u32,
data_ptr: u32,
@@ -2006,7 +2120,7 @@ pub mod env {
let mut topics: Vec<TopicOf<<E as Ext>::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.
@@ -2021,7 +2135,7 @@ pub mod env {
return Err(Error::<E::T>::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);
@@ -2036,7 +2150,8 @@ pub mod env {
/// backwards compatiblity.
#[prefixed_alias]
fn set_rent_allowance(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
_value_ptr: u32,
_value_len: u32,
) -> Result<(), TrapReason> {
@@ -2052,7 +2167,7 @@ pub mod env {
/// backwards compatiblity.
#[version(1)]
#[prefixed_alias]
- fn set_rent_allowance(ctx: Runtime<E>, _value_ptr: u32) -> Result<(), TrapReason> {
+ fn set_rent_allowance(ctx: _, _memory: _, _value_ptr: u32) -> Result<(), TrapReason> {
ctx.charge_gas(RuntimeCosts::DebugMessage)?;
Ok(())
}
@@ -2064,10 +2179,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<E>, 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 = <BalanceOf<E::T>>::max_value().encode();
Ok(ctx.write_sandbox_output(
+ memory,
out_ptr,
out_len_ptr,
&rent_allowance,
@@ -2083,9 +2199,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<E>, 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(),
@@ -2113,13 +2230,16 @@ pub mod env {
/// function will write the result directly into this buffer.
#[prefixed_alias]
fn hash_sha2_256(
- ctx: Runtime<E>,
+ 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.
@@ -2141,13 +2261,16 @@ pub mod env {
/// function will write the result directly into this buffer.
#[prefixed_alias]
fn hash_keccak_256(
- ctx: Runtime<E>,
+ 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.
@@ -2169,13 +2292,16 @@ pub mod env {
/// function will write the result directly into this buffer.
#[prefixed_alias]
fn hash_blake2_256(
- ctx: Runtime<E>,
+ 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.
@@ -2197,13 +2323,16 @@ pub mod env {
/// function will write the result directly into this buffer.
#[prefixed_alias]
fn hash_blake2_128(
- ctx: Runtime<E>,
+ 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.
@@ -2219,7 +2348,8 @@ pub mod env {
/// module error.
#[prefixed_alias]
fn call_chain_extension(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
id: u32,
input_ptr: u32,
input_len: u32,
@@ -2234,7 +2364,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 } =>
@@ -2263,13 +2394,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<E>,
+ ctx: _,
+ memory: _,
str_ptr: u32,
str_len: u32,
) -> Result<ReturnCode, TrapReason> {
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(|_| <Error<E::T>>::DebugMessageInvalidUTF8)?;
ctx.ext.append_debug_buffer(msg);
@@ -2318,14 +2450,15 @@ pub mod env {
#[unstable]
#[prefixed_alias]
fn call_runtime(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
call_ptr: u32,
call_len: u32,
) -> Result<ReturnCode, TrapReason> {
use frame_support::dispatch::{extract_actual_weight, GetDispatchInfo};
ctx.charge_gas(RuntimeCosts::CopyFromContract(call_len))?;
let call: <E::T as Config>::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);
@@ -2356,7 +2489,8 @@ pub mod env {
/// `ReturnCode::EcdsaRecoverFailed`
#[prefixed_alias]
fn ecdsa_recover(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
signature_ptr: u32,
message_hash_ptr: u32,
output_ptr: u32,
@@ -2364,9 +2498,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);
@@ -2374,7 +2508,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)
},
@@ -2410,9 +2544,10 @@ pub mod env {
///
/// `ReturnCode::CodeNotFound`
#[prefixed_alias]
- fn set_code_hash(ctx: Runtime<E>, code_hash_ptr: u32) -> Result<ReturnCode, TrapReason> {
+ fn set_code_hash(ctx: _, memory: _, code_hash_ptr: u32) -> Result<ReturnCode, TrapReason> {
ctx.charge_gas(RuntimeCosts::SetCodeHash)?;
- let code_hash: CodeHash<<E as Ext>::T> = ctx.read_sandbox_memory_as(code_hash_ptr)?;
+ let code_hash: CodeHash<<E as Ext>::T> =
+ ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
match ctx.ext.set_code_hash(code_hash) {
Err(err) => {
let code = Runtime::<E>::err_into_return_code(err)?;
@@ -2440,17 +2575,18 @@ pub mod env {
/// `ReturnCode::EcdsaRecoverFailed`
#[prefixed_alias]
fn ecdsa_to_eth_address(
- ctx: Runtime<E>,
+ ctx: _,
+ memory: _,
key_ptr: u32,
out_ptr: u32,
) -> Result<ReturnCode, TrapReason> {
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),
@@ -2464,9 +2600,9 @@ pub mod env {
///
/// Returns 0 when there is no reentrancy.
#[unstable]
- fn reentrant_count(ctx: Runtime<E>) -> Result<u32, TrapReason> {
+ fn reentrance_count(ctx: _, memory: _) -> Result<u32, TrapReason> {
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
@@ -2480,10 +2616,10 @@ pub mod env {
///
/// Returns 0 when the contract does not exist on the call stack.
#[unstable]
- fn account_reentrance_count(ctx: Runtime<E>, account_ptr: u32) -> Result<u32, TrapReason> {
+ fn account_reentrance_count(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
ctx.charge_gas(RuntimeCosts::AccountEntranceCount)?;
let account_id: <<E as Ext>::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))
}
}
diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs
index 4652413df1158..f5c12e92ca94e 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-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
// 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,7 +110,7 @@ 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_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;
@@ -169,17 +170,17 @@ pub struct SubstrateWeight<T>(PhantomData<T>);
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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_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: 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_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)))
@@ -187,10 +188,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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_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))
}
@@ -198,10 +199,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -212,10 +213,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -230,12 +231,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// 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_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))
}
@@ -248,10 +249,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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)
- // Standard Error: 1
- .saturating_add(Weight::from_ref_time(1_479 as u64).saturating_mul(s 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_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))
}
@@ -261,8 +262,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -272,10 +273,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -284,8 +285,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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_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))
}
@@ -293,8 +294,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -305,10 +306,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -319,10 +320,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -334,10 +335,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -349,10 +350,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -363,10 +364,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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_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))
}
@@ -377,10 +378,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -391,10 +392,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -405,10 +406,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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_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))
}
@@ -419,10 +420,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -433,10 +434,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -447,10 +448,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -461,10 +462,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -476,10 +477,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -490,10 +491,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -504,10 +505,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -518,10 +519,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -532,10 +533,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -546,10 +547,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -562,10 +563,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -579,10 +580,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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_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))
}
@@ -593,10 +594,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -608,12 +609,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// 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_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))
@@ -626,20 +627,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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: 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: 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))
@@ -648,10 +649,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -660,10 +661,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -672,10 +673,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -684,10 +685,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -696,10 +697,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -707,10 +708,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -718,10 +719,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -729,10 +730,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -740,10 +741,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -752,10 +753,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -768,10 +769,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -784,10 +785,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -800,10 +801,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -817,12 +818,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// 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_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))
@@ -837,10 +838,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -856,10 +857,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// 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_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))
@@ -872,10 +873,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -886,10 +887,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -900,10 +901,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -914,10 +915,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -928,10 +929,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -942,10 +943,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -956,10 +957,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -970,10 +971,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -984,10 +985,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -998,10 +999,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
}
@@ -1013,10 +1014,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: 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))
@@ -1026,382 +1027,386 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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 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))
}
// 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))
+ // 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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_128 nanoseconds.
+ Weight::from_ref_time(2_565_932 as u64)
+ // Standard Error: 76
+ .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: 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: 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: 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: 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: 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_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: 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_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: 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_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: 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_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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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))
}
}
@@ -1409,17 +1414,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
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_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: 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_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)))
@@ -1427,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_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_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))
}
@@ -1438,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: 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: 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))
}
@@ -1452,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: 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: 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))
}
@@ -1470,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_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_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))
}
@@ -1488,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: 213_409 nanoseconds.
- Weight::from_ref_time(205_300_495 as u64)
- // Standard Error: 1
- .saturating_add(Weight::from_ref_time(1_479 as u64).saturating_mul(s 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_487 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 +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: 183_317 nanoseconds.
- Weight::from_ref_time(184_465_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))
}
@@ -1512,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: 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: 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))
}
@@ -1524,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: 38_433 nanoseconds.
- Weight::from_ref_time(38_917_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))
}
@@ -1533,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: 41_507 nanoseconds.
- Weight::from_ref_time(41_938_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))
}
@@ -1545,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: 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: 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))
}
@@ -1559,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: 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: 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))
@@ -1574,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: 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: 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))
@@ -1589,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: 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: 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))
}
@@ -1603,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: 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_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))
}
@@ -1617,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: 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: 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))
}
@@ -1631,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: 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: 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))
}
@@ -1645,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: 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_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))
}
@@ -1659,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: 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: 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))
}
@@ -1673,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: 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: 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))
}
@@ -1687,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: 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: 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))
}
@@ -1701,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: 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: 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))
}
@@ -1716,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: 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: 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))
}
@@ -1730,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: 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: 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))
}
@@ -1744,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: 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: 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))
}
@@ -1758,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: 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: 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))
}
@@ -1772,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: 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: 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))
}
@@ -1786,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: 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: 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))
}
@@ -1802,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: 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: 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))
@@ -1819,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: 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_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))
}
@@ -1833,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: 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: 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))
}
@@ -1848,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_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_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))
@@ -1866,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: 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: 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: 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: 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))
@@ -1888,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: 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: 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))
@@ -1900,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: 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: 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))
@@ -1912,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: 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: 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))
@@ -1924,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: 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: 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))
@@ -1936,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: 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: 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))
@@ -1947,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: 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: 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))
@@ -1958,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: 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: 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))
@@ -1969,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: 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: 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))
@@ -1980,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: 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: 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))
@@ -1992,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: 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: 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))
@@ -2008,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: 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: 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))
@@ -2024,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: 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: 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))
@@ -2040,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: 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: 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))
@@ -2057,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: 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_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))
@@ -2077,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: 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: 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))
@@ -2096,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: 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_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))
@@ -2112,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: 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: 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))
}
@@ -2126,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: 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: 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))
}
@@ -2140,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: 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: 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))
}
@@ -2154,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: 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: 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))
}
@@ -2168,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: 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: 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))
}
@@ -2182,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: 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: 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))
}
@@ -2196,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: 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: 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))
}
@@ -2210,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: 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: 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))
}
@@ -2224,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: 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: 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))
}
@@ -2238,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: 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: 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))
}
@@ -2253,10 +2258,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: 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))
@@ -2266,381 +2271,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 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))
}
// 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))
+ // 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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_128 nanoseconds.
+ Weight::from_ref_time(2_565_932 as u64)
+ // Standard Error: 76
+ .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: 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: 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: 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: 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: 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_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: 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_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: 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_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: 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_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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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))
}
-}
\ No newline at end of file
+}