diff --git a/frame/contracts/fixtures/new_set_code_hash_contract.wat b/frame/contracts/fixtures/new_set_code_hash_contract.wat new file mode 100644 index 0000000000000..86ab2737be484 --- /dev/null +++ b/frame/contracts/fixtures/new_set_code_hash_contract.wat @@ -0,0 +1,13 @@ +(module + (import "seal0" "seal_return" (func $seal_return (param i32 i32 i32))) + (import "env" "memory" (memory 1 1)) + + ;; [0, 32) return value + (data (i32.const 0) "\02") + + (func (export "deploy")) + + (func (export "call") + (call $seal_return (i32.const 0) (i32.const 0) (i32.const 4)) + ) +) diff --git a/frame/contracts/fixtures/set_code_hash.wat b/frame/contracts/fixtures/set_code_hash.wat new file mode 100644 index 0000000000000..0a7b2e7cbedfa --- /dev/null +++ b/frame/contracts/fixtures/set_code_hash.wat @@ -0,0 +1,43 @@ +(module + (import "seal0" "seal_input" (func $seal_input (param i32 i32))) + (import "seal0" "seal_return" (func $seal_return (param i32 i32 i32))) + (import "__unstable__" "seal_set_code_hash" (func $seal_set_code_hash (param i32) (result i32))) + + (import "env" "memory" (memory 1 1)) + + ;; [0, 32) here we store input + + ;; [32, 36) input size + (data (i32.const 32) "\20") + + ;; [36, 40) return value + (data (i32.const 36) "\01") + + (func $assert (param i32) + (block $ok + (br_if $ok + (get_local 0) + ) + (unreachable) + ) + ) + + (func (export "call") + (local $exit_code i32) + + (call $seal_input (i32.const 0) (i32.const 32)) + + (set_local $exit_code + (call $seal_set_code_hash (i32.const 0)) ;; Pointer to the input data. + ) + (call $assert + (i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success + ) + + ;; we return 1 after setting new code_hash + ;; next `call` will NOT return this value, because contract code has been changed + (call $seal_return (i32.const 0) (i32.const 36) (i32.const 4)) + ) + + (func (export "deploy")) +) diff --git a/frame/contracts/src/benchmarking/mod.rs b/frame/contracts/src/benchmarking/mod.rs index 88405eba44205..b18b40d0b3345 100644 --- a/frame/contracts/src/benchmarking/mod.rs +++ b/frame/contracts/src/benchmarking/mod.rs @@ -1971,6 +1971,46 @@ benchmarks! { let origin = RawOrigin::Signed(instance.caller.clone()); }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) + seal_set_code_hash { + let r in 0 .. API_BENCHMARK_BATCHES; + let code_hashes = (0..r * API_BENCHMARK_BATCH_SIZE) + .map(|i| { + let new_code = WasmModule::::dummy_with_bytes(i); + Contracts::::store_code_raw(new_code.code, whitelisted_caller())?; + Ok(new_code.hash) + }) + .collect::, &'static str>>()?; + let code_hash_len = code_hashes.get(0).map(|x| x.encode().len()).unwrap_or(0); + let code_hashes_bytes = code_hashes.iter().flat_map(|x| x.encode()).collect::>(); + let code_hashes_len = code_hashes_bytes.len(); + + let code = WasmModule::::from(ModuleDefinition { + memory: Some(ImportedMemory::max::()), + imported_functions: vec![ImportedFunction { + module: "__unstable__", + name: "seal_set_code_hash", + params: vec![ + ValueType::I32, + ], + return_type: Some(ValueType::I32), + }], + data_segments: vec![ + DataSegment { + offset: 0, + value: code_hashes_bytes, + }, + ], + call_body: Some(body::repeated_dyn(r * API_BENCHMARK_BATCH_SIZE, vec![ + Counter(0, code_hash_len as u32), // code_hash_ptr + Regular(Instruction::Call(0)), + Regular(Instruction::Drop), + ])), + .. Default::default() + }); + let instance = Contract::::new(code, vec![])?; + let origin = RawOrigin::Signed(instance.caller.clone()); + }: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![]) + // We make the assumption that pushing a constant and dropping a value takes roughly // the same amount of time. We follow that `t.load` and `drop` both have the weight // of this benchmark / 2. We need to make this assumption because there is no way diff --git a/frame/contracts/src/exec.rs b/frame/contracts/src/exec.rs index c6e647e0c8d96..bca74cd66ced7 100644 --- a/frame/contracts/src/exec.rs +++ b/frame/contracts/src/exec.rs @@ -18,6 +18,7 @@ use crate::{ gas::GasMeter, storage::{self, Storage, WriteOutcome}, + wasm::{decrement_refcount, increment_refcount}, AccountCounter, BalanceOf, CodeHash, Config, ContractInfo, ContractInfoOf, Error, Event, Pallet as Contracts, Schedule, }; @@ -239,6 +240,9 @@ pub trait Ext: sealing::Sealed { /// Tests sometimes need to modify and inspect the contract info directly. #[cfg(test)] fn contract_info(&mut self) -> &mut ContractInfo; + + /// Sets new code hash for existing contract. + fn set_code_hash(&mut self, hash: CodeHash) -> Result<(), DispatchError>; } /// Describes the different functions that can be exported by an [`Executable`]. @@ -1182,6 +1186,20 @@ where fn contract_info(&mut self) -> &mut ContractInfo { self.top_frame_mut().contract_info() } + + fn set_code_hash(&mut self, hash: CodeHash) -> Result<(), DispatchError> { + increment_refcount::(hash)?; + let top_frame = self.top_frame_mut(); + let prev_hash = top_frame.contract_info().code_hash.clone(); + decrement_refcount::(prev_hash.clone())?; + top_frame.contract_info().code_hash = hash; + Contracts::::deposit_event(Event::ContractCodeUpdated { + contract: top_frame.account_id.clone(), + new_code_hash: hash, + old_code_hash: prev_hash, + }); + Ok(()) + } } fn deposit_event(topics: Vec, event: Event) { diff --git a/frame/contracts/src/lib.rs b/frame/contracts/src/lib.rs index 7e4515868b745..9e7b61301e7de 100644 --- a/frame/contracts/src/lib.rs +++ b/frame/contracts/src/lib.rs @@ -564,6 +564,16 @@ pub mod pallet { /// A code with the specified hash was removed. CodeRemoved { code_hash: T::Hash }, + + /// A contract's code was updated. + ContractCodeUpdated { + /// The contract that has been updated. + contract: T::AccountId, + /// New code hash that was set for the contract. + new_code_hash: T::Hash, + /// Previous code hash of the contract. + old_code_hash: T::Hash, + }, } #[pallet::error] diff --git a/frame/contracts/src/schedule.rs b/frame/contracts/src/schedule.rs index e599bdc3125bd..c92d2dd616106 100644 --- a/frame/contracts/src/schedule.rs +++ b/frame/contracts/src/schedule.rs @@ -328,6 +328,9 @@ pub struct HostFnWeights { /// Weight per overwritten byte of an item stored with `seal_set_storage`. pub set_storage_per_old_byte: Weight, + /// Weight of calling `seal_set_code_hash`. + pub set_code_hash: Weight, + /// Weight of calling `seal_clear_storage`. pub clear_storage: Weight, @@ -606,6 +609,7 @@ impl Default for HostFnWeights { ), debug_message: cost_batched!(seal_debug_message), set_storage: cost_batched!(seal_set_storage), + set_code_hash: cost_batched!(seal_set_code_hash), set_storage_per_new_byte: cost_byte_batched!(seal_set_storage_per_new_kb), set_storage_per_old_byte: cost_byte_batched!(seal_set_storage_per_old_kb), clear_storage: cost_batched!(seal_clear_storage), diff --git a/frame/contracts/src/tests.rs b/frame/contracts/src/tests.rs index 6919705206d4a..486e84da75471 100644 --- a/frame/contracts/src/tests.rs +++ b/frame/contracts/src/tests.rs @@ -3023,3 +3023,64 @@ fn code_rejected_error_works() { ); }); } + +#[test] +#[cfg(feature = "unstable-interface")] +fn set_code_hash() { + let (wasm, code_hash) = compile_module::("set_code_hash").unwrap(); + let (new_wasm, new_code_hash) = compile_module::("new_set_code_hash_contract").unwrap(); + + let contract_addr = Contracts::contract_address(&ALICE, &code_hash, &[]); + + ExtBuilder::default().existential_deposit(100).build().execute_with(|| { + let _ = Balances::deposit_creating(&ALICE, 1_000_000); + + // Instantiate the 'caller' + assert_ok!(Contracts::instantiate_with_code( + Origin::signed(ALICE), + 300_000, + GAS_LIMIT, + None, + wasm, + vec![], + vec![], + )); + // upload new code + assert_ok!(Contracts::upload_code(Origin::signed(ALICE), new_wasm.clone(), None)); + + // First call sets new code_hash and returns 1 + let result = Contracts::bare_call( + ALICE, + contract_addr.clone(), + 0, + GAS_LIMIT, + None, + new_code_hash.as_ref().to_vec(), + true, + ) + .result + .unwrap(); + assert_return_code!(result, 1); + + // Second calls new contract code that returns 2 + let result = + Contracts::bare_call(ALICE, contract_addr.clone(), 0, GAS_LIMIT, None, vec![], true) + .result + .unwrap(); + assert_return_code!(result, 2); + + // Checking for the last event only + assert_eq!( + System::events().pop().unwrap(), + EventRecord { + phase: Phase::Initialization, + event: Event::Contracts(crate::Event::ContractCodeUpdated { + contract: contract_addr.clone(), + new_code_hash: new_code_hash.clone(), + old_code_hash: code_hash.clone(), + }), + topics: vec![], + }, + ); + }); +} diff --git a/frame/contracts/src/wasm/code_cache.rs b/frame/contracts/src/wasm/code_cache.rs index a48f9838837c9..9a447066667bd 100644 --- a/frame/contracts/src/wasm/code_cache.rs +++ b/frame/contracts/src/wasm/code_cache.rs @@ -117,6 +117,22 @@ pub fn decrement_refcount(code_hash: CodeHash) -> Result<(), Dispa Ok(()) } +/// Increment the refcount of a code in-storage by one. +/// +/// # Errors +/// +/// [`Error::CodeNotFound`] is returned if the specified `code_hash` does not exist. +pub fn increment_refcount(code_hash: CodeHash) -> Result<(), DispatchError> { + >::mutate(code_hash, |existing| -> Result<(), DispatchError> { + if let Some(info) = existing { + info.refcount = info.refcount.saturating_add(1); + Ok(()) + } else { + Err(Error::::CodeNotFound.into()) + } + }) +} + /// Try to remove code together with all associated information. pub fn try_remove(origin: &T::AccountId, code_hash: CodeHash) -> DispatchResult { >::try_mutate_exists(&code_hash, |existing| { diff --git a/frame/contracts/src/wasm/mod.rs b/frame/contracts/src/wasm/mod.rs index 3be1062ce969a..c5e5b476d3a22 100644 --- a/frame/contracts/src/wasm/mod.rs +++ b/frame/contracts/src/wasm/mod.rs @@ -26,7 +26,10 @@ mod runtime; #[cfg(feature = "runtime-benchmarks")] pub use self::code_cache::reinstrument; -pub use self::runtime::{ReturnCode, Runtime, RuntimeCosts}; +pub use self::{ + code_cache::{decrement_refcount, increment_refcount}, + runtime::{ReturnCode, Runtime, RuntimeCosts}, +}; use crate::{ exec::{ExecResult, Executable, ExportedFunction, Ext}, gas::GasMeter, @@ -322,6 +325,7 @@ mod tests { gas_meter: GasMeter, debug_buffer: Vec, ecdsa_recover: RefCell>, + code_hashes: Vec>, } /// The call is mocked and just returns this hardcoded value. @@ -332,6 +336,7 @@ mod tests { impl Default for MockExt { fn default() -> Self { Self { + code_hashes: Default::default(), storage: Default::default(), instantiates: Default::default(), terminations: Default::default(), @@ -390,6 +395,10 @@ mod tests { ExecReturnValue { flags: ReturnFlags::empty(), data: Bytes(Vec::new()) }, )) } + fn set_code_hash(&mut self, hash: CodeHash) -> Result<(), DispatchError> { + self.code_hashes.push(hash); + Ok(()) + } fn transfer(&mut self, to: &AccountIdOf, value: u64) -> Result<(), DispatchError> { self.transfers.push(TransferEntry { to: to.clone(), value }); Ok(()) @@ -798,6 +807,67 @@ mod tests { ); } + #[test] + #[cfg(feature = "unstable-interface")] + fn contains_storage_works() { + const CODE: &str = r#" +(module + (import "seal0" "seal_return" (func $seal_return (param i32 i32 i32))) + (import "seal0" "seal_input" (func $seal_input (param i32 i32))) + (import "__unstable__" "seal_contains_storage" (func $seal_contains_storage (param i32) (result i32))) + (import "env" "memory" (memory 1 1)) + + ;; [0, 4) size of input buffer (32 byte as we copy the key here) + (data (i32.const 0) "\20") + + ;; [4, 36) input buffer + + ;; [36, inf) output buffer + + (func (export "call") + ;; Receive key + (call $seal_input + (i32.const 4) ;; Pointer to the input buffer + (i32.const 0) ;; Size of the length buffer + ) + + ;; Load the return value into the output buffer + (i32.store (i32.const 36) + (call $seal_contains_storage + (i32.const 4) ;; The pointer to the storage key to fetch + ) + ) + + ;; Return the contents of the buffer + (call $seal_return + (i32.const 0) ;; flags + (i32.const 36) ;; output buffer ptr + (i32.const 4) ;; result is integer (4 bytes) + ) + ) + + (func (export "deploy")) +) +"#; + + let mut ext = MockExt::default(); + + ext.storage.insert([1u8; 32], vec![42u8]); + ext.storage.insert([2u8; 32], vec![]); + + // value does not exist -> sentinel value returned + let result = execute(CODE, [3u8; 32].encode(), &mut ext).unwrap(); + assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL); + + // value did exist -> success + let result = execute(CODE, [1u8; 32].encode(), &mut ext).unwrap(); + assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 1,); + + // value did exist -> success (zero sized type) + let result = execute(CODE, [2u8; 32].encode(), &mut ext).unwrap(); + assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0,); + } + const CODE_INSTANTIATE: &str = r#" (module ;; seal_instantiate( @@ -2249,67 +2319,6 @@ mod tests { assert_eq!(&result.data.0[4..], &[0u8; 0]); } - #[test] - #[cfg(feature = "unstable-interface")] - fn contains_storage_works() { - const CODE: &str = r#" -(module - (import "seal0" "seal_return" (func $seal_return (param i32 i32 i32))) - (import "seal0" "seal_input" (func $seal_input (param i32 i32))) - (import "__unstable__" "seal_contains_storage" (func $seal_contains_storage (param i32) (result i32))) - (import "env" "memory" (memory 1 1)) - - ;; [0, 4) size of input buffer (32 byte as we copy the key here) - (data (i32.const 0) "\20") - - ;; [4, 36) input buffer - - ;; [36, inf) output buffer - - (func (export "call") - ;; Receive key - (call $seal_input - (i32.const 4) ;; Pointer to the input buffer - (i32.const 0) ;; Size of the length buffer - ) - - ;; Load the return value into the output buffer - (i32.store (i32.const 36) - (call $seal_contains_storage - (i32.const 4) ;; The pointer to the storage key to fetch - ) - ) - - ;; Return the contents of the buffer - (call $seal_return - (i32.const 0) ;; flags - (i32.const 36) ;; output buffer ptr - (i32.const 4) ;; result is integer (4 bytes) - ) - ) - - (func (export "deploy")) -) -"#; - - let mut ext = MockExt::default(); - - ext.storage.insert([1u8; 32], vec![42u8]); - ext.storage.insert([2u8; 32], vec![]); - - // value does not exist -> sentinel value returned - let result = execute(CODE, [3u8; 32].encode(), &mut ext).unwrap(); - assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), crate::SENTINEL); - - // value did exist -> success - let result = execute(CODE, [1u8; 32].encode(), &mut ext).unwrap(); - assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 1,); - - // value did exist -> success (zero sized type) - let result = execute(CODE, [2u8; 32].encode(), &mut ext).unwrap(); - assert_eq!(u32::from_le_bytes(result.data.0.try_into().unwrap()), 0,); - } - #[test] #[cfg(feature = "unstable-interface")] fn is_contract_works() { @@ -2385,4 +2394,45 @@ mod tests { ExecReturnValue { flags: ReturnFlags::empty(), data: Bytes(0u32.encode()) }, ); } + + #[test] + #[cfg(feature = "unstable-interface")] + fn set_code_hash() { + const CODE: &str = r#" +(module + (import "__unstable__" "seal_set_code_hash" (func $seal_set_code_hash (param i32) (result i32))) + (import "env" "memory" (memory 1 1)) + (func $assert (param i32) + (block $ok + (br_if $ok + (get_local 0) + ) + (unreachable) + ) + ) + (func (export "call") + (local $exit_code i32) + (set_local $exit_code + (call $seal_set_code_hash (i32.const 0)) + ) + (call $assert + (i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success + ) + ) + + (func (export "deploy")) + + ;; Hash of code. + (data (i32.const 0) + "\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11" + "\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11" + ) +) +"#; + + let mut mock_ext = MockExt::default(); + execute(CODE, [0u8; 32].encode(), &mut mock_ext).unwrap(); + + assert_eq!(mock_ext.code_hashes.pop().unwrap(), H256::from_slice(&[17u8; 32])); + } } diff --git a/frame/contracts/src/wasm/runtime.rs b/frame/contracts/src/wasm/runtime.rs index 55ab0dfa0adef..384fbff9809b7 100644 --- a/frame/contracts/src/wasm/runtime.rs +++ b/frame/contracts/src/wasm/runtime.rs @@ -222,6 +222,9 @@ pub enum RuntimeCosts { /// Weight charged for calling into the runtime. #[cfg(feature = "unstable-interface")] CallRuntime(Weight), + /// Weight of calling `seal_set_code_hash` + #[cfg(feature = "unstable-interface")] + SetCodeHash, } impl RuntimeCosts { @@ -305,6 +308,8 @@ impl RuntimeCosts { CopyIn(len) => s.return_per_byte.saturating_mul(len.into()), #[cfg(feature = "unstable-interface")] CallRuntime(weight) => weight, + #[cfg(feature = "unstable-interface")] + SetCodeHash => s.set_code_hash, }; RuntimeToken { #[cfg(test)] @@ -1960,4 +1965,41 @@ define_env!(Env, , Err(_) => Ok(ReturnCode::EcdsaRecoverFailed), } }, + + // Replace the contract code at the specified address with new code. + // + // # Note + // + // There are a couple of important considerations which must be taken into account when + // using this API: + // + // 1. The storage at the code address will remain untouched. This means that contract developers + // must ensure that the storage layout of the new code is compatible with that of the old code. + // + // 2. Contracts using this API can't be assumed as having deterministic addresses. Said another way, + // when using this API you lose the guarantee that an address always identifies a specific code hash. + // + // 3. If a contract calls into itself after changing its code the new call would use + // the new code. However, if the original caller panics after returning from the sub call it + // would revert the changes made by `seal_set_code_hash` and the next caller would use + // the old code. + // + // # Parameters + // + // - code_hash_ptr: A pointer to the buffer that contains the new code hash. + // + // # Errors + // + // `ReturnCode::CodeNotFound` + [__unstable__] seal_set_code_hash(ctx, code_hash_ptr: u32) -> ReturnCode => { + ctx.charge_gas(RuntimeCosts::SetCodeHash)?; + let code_hash: CodeHash<::T> = ctx.read_sandbox_memory_as(code_hash_ptr)?; + match ctx.ext.set_code_hash(code_hash) { + Err(err) => { + let code = Runtime::::err_into_return_code(err)?; + Ok(code) + }, + Ok(()) => Ok(ReturnCode::Success) + } + }, ); diff --git a/frame/contracts/src/weights.rs b/frame/contracts/src/weights.rs index ec6dcd2eee892..bf35ce511ab26 100644 --- a/frame/contracts/src/weights.rs +++ b/frame/contracts/src/weights.rs @@ -18,7 +18,7 @@ //! Autogenerated weights for pallet_contracts //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-02-04, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2022-02-10, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 // Executed Command: @@ -101,6 +101,7 @@ pub trait WeightInfo { fn seal_hash_blake2_128(r: u32, ) -> Weight; fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight; fn seal_ecdsa_recover(r: u32, ) -> Weight; + fn seal_set_code_hash(r: u32, ) -> Weight; fn instr_i64const(r: u32, ) -> Weight; fn instr_i64load(r: u32, ) -> Weight; fn instr_i64store(r: u32, ) -> Weight; @@ -159,32 +160,32 @@ pub struct SubstrateWeight(PhantomData); impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_initialize() -> Weight { - (1_640_000 as Weight) + (1_590_000 as Weight) .saturating_add(T::DbWeight::get().reads(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn on_initialize_per_trie_key(k: u32, ) -> Weight { - (6_385_000 as Weight) + (9_975_000 as Weight) // Standard Error: 0 - .saturating_add((748_000 as Weight).saturating_mul(k as Weight)) + .saturating_add((724_000 as Weight).saturating_mul(k as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) .saturating_add(T::DbWeight::get().writes((1 as Weight).saturating_mul(k as Weight))) } // Storage: Contracts DeletionQueue (r:1 w:0) fn on_initialize_per_queue_item(q: u32, ) -> Weight { - (0 as Weight) - // Standard Error: 5_000 - .saturating_add((2_304_000 as Weight).saturating_mul(q as Weight)) + (7_415_000 as Weight) + // Standard Error: 4_000 + .saturating_add((2_303_000 as Weight).saturating_mul(q as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Contracts PristineCode (r:1 w:0) // Storage: Contracts CodeStorage (r:0 w:1) fn reinstrument(c: u32, ) -> Weight { - (22_923_000 as Weight) - // Standard Error: 33_000 - .saturating_add((65_851_000 as Weight).saturating_mul(c as Weight)) + (18_519_000 as Weight) + // Standard Error: 36_000 + .saturating_add((66_661_000 as Weight).saturating_mul(c as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -193,9 +194,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System Account (r:1 w:1) fn call_with_code_kb(c: u32, ) -> Weight { - (209_577_000 as Weight) - // Standard Error: 53_000 - .saturating_add((61_341_000 as Weight).saturating_mul(c as Weight)) + (210_319_000 as Weight) + // Standard Error: 41_000 + .saturating_add((54_802_000 as Weight).saturating_mul(c as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } @@ -207,11 +208,11 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts PristineCode (r:0 w:1) // Storage: Contracts OwnerInfoOf (r:0 w:1) fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - (240_302_000 as Weight) - // Standard Error: 119_000 - .saturating_add((151_894_000 as Weight).saturating_mul(c as Weight)) - // Standard Error: 7_000 - .saturating_add((1_740_000 as Weight).saturating_mul(s as Weight)) + (220_394_000 as Weight) + // Standard Error: 129_000 + .saturating_add((145_155_000 as Weight).saturating_mul(c as Weight)) + // Standard Error: 8_000 + .saturating_add((1_741_000 as Weight).saturating_mul(s as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(6 as Weight)) } @@ -222,9 +223,9 @@ impl WeightInfo for SubstrateWeight { // Storage: System Account (r:1 w:1) // Storage: Contracts OwnerInfoOf (r:1 w:1) fn instantiate(s: u32, ) -> Weight { - (172_047_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_729_000 as Weight).saturating_mul(s as Weight)) + (171_438_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_721_000 as Weight).saturating_mul(s as Weight)) .saturating_add(T::DbWeight::get().reads(6 as Weight)) .saturating_add(T::DbWeight::get().writes(5 as Weight)) } @@ -233,7 +234,7 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System Account (r:1 w:1) fn call() -> Weight { - (139_349_000 as Weight) + (139_529_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } @@ -241,9 +242,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts PristineCode (r:0 w:1) // Storage: Contracts OwnerInfoOf (r:0 w:1) fn upload_code(c: u32, ) -> Weight { - (50_449_000 as Weight) - // Standard Error: 45_000 - .saturating_add((68_254_000 as Weight).saturating_mul(c as Weight)) + (51_040_000 as Weight) + // Standard Error: 38_000 + .saturating_add((65_886_000 as Weight).saturating_mul(c as Weight)) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(3 as Weight)) } @@ -251,7 +252,7 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - (24_576_000 as Weight) + (24_347_000 as Weight) .saturating_add(T::DbWeight::get().reads(1 as Weight)) .saturating_add(T::DbWeight::get().writes(3 as Weight)) } @@ -260,9 +261,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_caller(r: u32, ) -> Weight { - (220_059_000 as Weight) - // Standard Error: 128_000 - .saturating_add((49_607_000 as Weight).saturating_mul(r as Weight)) + (217_164_000 as Weight) + // Standard Error: 89_000 + .saturating_add((48_023_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -271,9 +272,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_is_contract(r: u32, ) -> Weight { - (84_138_000 as Weight) - // Standard Error: 896_000 - .saturating_add((375_553_000 as Weight).saturating_mul(r as Weight)) + (81_537_000 as Weight) + // Standard Error: 847_000 + .saturating_add((367_429_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -283,9 +284,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_caller_is_origin(r: u32, ) -> Weight { - (222_496_000 as Weight) - // Standard Error: 119_000 - .saturating_add((22_340_000 as Weight).saturating_mul(r as Weight)) + (214_798_000 as Weight) + // Standard Error: 56_000 + .saturating_add((21_100_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -294,9 +295,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_address(r: u32, ) -> Weight { - (221_446_000 as Weight) - // Standard Error: 131_000 - .saturating_add((49_401_000 as Weight).saturating_mul(r as Weight)) + (216_615_000 as Weight) + // Standard Error: 75_000 + .saturating_add((48_054_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -305,9 +306,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_gas_left(r: u32, ) -> Weight { - (220_964_000 as Weight) - // Standard Error: 132_000 - .saturating_add((49_230_000 as Weight).saturating_mul(r as Weight)) + (218_034_000 as Weight) + // Standard Error: 87_000 + .saturating_add((47_594_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -316,9 +317,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_balance(r: u32, ) -> Weight { - (229_399_000 as Weight) - // Standard Error: 166_000 - .saturating_add((137_407_000 as Weight).saturating_mul(r as Weight)) + (221_980_000 as Weight) + // Standard Error: 135_000 + .saturating_add((135_618_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -327,9 +328,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_value_transferred(r: u32, ) -> Weight { - (220_103_000 as Weight) - // Standard Error: 133_000 - .saturating_add((49_410_000 as Weight).saturating_mul(r as Weight)) + (217_623_000 as Weight) + // Standard Error: 86_000 + .saturating_add((47_656_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -338,9 +339,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_minimum_balance(r: u32, ) -> Weight { - (228_143_000 as Weight) - // Standard Error: 151_000 - .saturating_add((48_608_000 as Weight).saturating_mul(r as Weight)) + (216_826_000 as Weight) + // Standard Error: 88_000 + .saturating_add((47_644_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -349,9 +350,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_block_number(r: u32, ) -> Weight { - (223_899_000 as Weight) - // Standard Error: 142_000 - .saturating_add((48_841_000 as Weight).saturating_mul(r as Weight)) + (219_487_000 as Weight) + // Standard Error: 90_000 + .saturating_add((47_167_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -360,9 +361,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_now(r: u32, ) -> Weight { - (224_974_000 as Weight) - // Standard Error: 148_000 - .saturating_add((48_902_000 as Weight).saturating_mul(r as Weight)) + (218_953_000 as Weight) + // Standard Error: 95_000 + .saturating_add((47_458_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -372,9 +373,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) fn seal_weight_to_fee(r: u32, ) -> Weight { - (227_556_000 as Weight) - // Standard Error: 151_000 - .saturating_add((121_252_000 as Weight).saturating_mul(r as Weight)) + (220_132_000 as Weight) + // Standard Error: 144_000 + .saturating_add((120_373_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -383,9 +384,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_gas(r: u32, ) -> Weight { - (127_975_000 as Weight) - // Standard Error: 57_000 - .saturating_add((24_843_000 as Weight).saturating_mul(r as Weight)) + (127_458_000 as Weight) + // Standard Error: 56_000 + .saturating_add((24_015_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -394,9 +395,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_input(r: u32, ) -> Weight { - (224_592_000 as Weight) - // Standard Error: 141_000 - .saturating_add((48_296_000 as Weight).saturating_mul(r as Weight)) + (220_304_000 as Weight) + // Standard Error: 112_000 + .saturating_add((46_804_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -405,9 +406,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_input_per_kb(n: u32, ) -> Weight { - (296_995_000 as Weight) - // Standard Error: 3_000 - .saturating_add((11_884_000 as Weight).saturating_mul(n as Weight)) + (300_916_000 as Weight) + // Standard Error: 8_000 + .saturating_add((10_552_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -415,8 +416,10 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) - fn seal_return(_r: u32, ) -> Weight { - (224_322_000 as Weight) + fn seal_return(r: u32, ) -> Weight { + (211_812_000 as Weight) + // Standard Error: 138_000 + .saturating_add((1_698_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -425,9 +428,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_return_per_kb(n: u32, ) -> Weight { - (216_240_000 as Weight) - // Standard Error: 1_000 - .saturating_add((206_000 as Weight).saturating_mul(n as Weight)) + (213_994_000 as Weight) + // Standard Error: 0 + .saturating_add((176_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -438,9 +441,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts DeletionQueue (r:1 w:1) // Storage: Contracts OwnerInfoOf (r:1 w:1) fn seal_terminate(r: u32, ) -> Weight { - (219_637_000 as Weight) - // Standard Error: 3_916_000 - .saturating_add((51_769_000 as Weight).saturating_mul(r as Weight)) + (215_173_000 as Weight) + // Standard Error: 708_000 + .saturating_add((52_509_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().reads((4 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -452,9 +455,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) fn seal_random(r: u32, ) -> Weight { - (221_470_000 as Weight) - // Standard Error: 154_000 - .saturating_add((158_758_000 as Weight).saturating_mul(r as Weight)) + (219_521_000 as Weight) + // Standard Error: 171_000 + .saturating_add((156_228_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -463,9 +466,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_deposit_event(r: u32, ) -> Weight { - (228_674_000 as Weight) - // Standard Error: 203_000 - .saturating_add((287_195_000 as Weight).saturating_mul(r as Weight)) + (227_624_000 as Weight) + // Standard Error: 193_000 + .saturating_add((285_058_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -475,11 +478,11 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:100 w:100) fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - (507_091_000 as Weight) - // Standard Error: 1_863_000 - .saturating_add((291_858_000 as Weight).saturating_mul(t as Weight)) - // Standard Error: 367_000 - .saturating_add((83_459_000 as Weight).saturating_mul(n as Weight)) + (503_312_000 as Weight) + // Standard Error: 1_729_000 + .saturating_add((288_009_000 as Weight).saturating_mul(t as Weight)) + // Standard Error: 340_000 + .saturating_add((80_936_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(t as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -490,17 +493,17 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_debug_message(r: u32, ) -> Weight { - (133_592_000 as Weight) - // Standard Error: 87_000 - .saturating_add((41_718_000 as Weight).saturating_mul(r as Weight)) + (132_096_000 as Weight) + // Standard Error: 73_000 + .saturating_add((40_337_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_set_storage(r: u32, ) -> Weight { - (44_719_000 as Weight) - // Standard Error: 1_036_000 - .saturating_add((407_521_000 as Weight).saturating_mul(r as Weight)) + (52_622_000 as Weight) + // Standard Error: 1_006_000 + .saturating_add((404_716_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -508,25 +511,25 @@ impl WeightInfo for SubstrateWeight { } // Storage: Skipped Metadata (r:0 w:0) fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - (606_108_000 as Weight) - // Standard Error: 315_000 - .saturating_add((29_136_000 as Weight).saturating_mul(n as Weight)) + (601_324_000 as Weight) + // Standard Error: 264_000 + .saturating_add((27_943_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(105 as Weight)) .saturating_add(T::DbWeight::get().writes(103 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - (634_330_000 as Weight) - // Standard Error: 281_000 - .saturating_add((10_741_000 as Weight).saturating_mul(n as Weight)) + (626_752_000 as Weight) + // Standard Error: 292_000 + .saturating_add((10_616_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(105 as Weight)) .saturating_add(T::DbWeight::get().writes(103 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_clear_storage(r: u32, ) -> Weight { - (89_750_000 as Weight) - // Standard Error: 924_000 - .saturating_add((382_525_000 as Weight).saturating_mul(r as Weight)) + (80_138_000 as Weight) + // Standard Error: 933_000 + .saturating_add((382_949_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(3 as Weight)) @@ -534,51 +537,51 @@ impl WeightInfo for SubstrateWeight { } // Storage: Skipped Metadata (r:0 w:0) fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - (616_463_000 as Weight) - // Standard Error: 260_000 - .saturating_add((10_373_000 as Weight).saturating_mul(n as Weight)) + (603_984_000 as Weight) + // Standard Error: 242_000 + .saturating_add((10_712_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(105 as Weight)) .saturating_add(T::DbWeight::get().writes(103 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_get_storage(r: u32, ) -> Weight { - (116_340_000 as Weight) - // Standard Error: 633_000 - .saturating_add((322_054_000 as Weight).saturating_mul(r as Weight)) + (113_136_000 as Weight) + // Standard Error: 635_000 + .saturating_add((324_706_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_get_storage_per_kb(n: u32, ) -> Weight { - (563_077_000 as Weight) - // Standard Error: 340_000 - .saturating_add((63_889_000 as Weight).saturating_mul(n as Weight)) + (562_781_000 as Weight) + // Standard Error: 354_000 + .saturating_add((63_275_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(104 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_contains_storage(r: u32, ) -> Weight { - (118_832_000 as Weight) - // Standard Error: 595_000 - .saturating_add((291_817_000 as Weight).saturating_mul(r as Weight)) + (112_237_000 as Weight) + // Standard Error: 655_000 + .saturating_add((296_653_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - (520_386_000 as Weight) - // Standard Error: 297_000 - .saturating_add((10_076_000 as Weight).saturating_mul(n as Weight)) + (520_002_000 as Weight) + // Standard Error: 232_000 + .saturating_add((9_726_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(104 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_take_storage(r: u32, ) -> Weight { - (85_377_000 as Weight) - // Standard Error: 847_000 - .saturating_add((419_438_000 as Weight).saturating_mul(r as Weight)) + (87_232_000 as Weight) + // Standard Error: 920_000 + .saturating_add((415_305_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(3 as Weight)) @@ -586,9 +589,9 @@ impl WeightInfo for SubstrateWeight { } // Storage: Skipped Metadata (r:0 w:0) fn seal_take_storage_per_kb(n: u32, ) -> Weight { - (666_218_000 as Weight) - // Standard Error: 294_000 - .saturating_add((64_627_000 as Weight).saturating_mul(n as Weight)) + (648_862_000 as Weight) + // Standard Error: 319_000 + .saturating_add((63_991_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(105 as Weight)) .saturating_add(T::DbWeight::get().writes(103 as Weight)) } @@ -597,9 +600,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_transfer(r: u32, ) -> Weight { - (108_224_000 as Weight) - // Standard Error: 1_042_000 - .saturating_add((1_723_539_000 as Weight).saturating_mul(r as Weight)) + (99_621_000 as Weight) + // Standard Error: 1_154_000 + .saturating_add((1_732_052_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(2 as Weight)) @@ -611,8 +614,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) fn seal_call(r: u32, ) -> Weight { (0 as Weight) - // Standard Error: 7_843_000 - .saturating_add((19_825_093_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 6_293_000 + .saturating_add((19_410_115_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) @@ -624,8 +627,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Timestamp Now (r:1 w:0) fn seal_delegate_call(r: u32, ) -> Weight { (0 as Weight) - // Standard Error: 11_788_000 - .saturating_add((19_855_594_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 7_155_000 + .saturating_add((19_793_614_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads((99 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -634,13 +637,13 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:2 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_call_per_transfer_input_output_kb(t: u32, i: u32, o: u32, ) -> Weight { - (20_190_331_000 as Weight) - // Standard Error: 75_647_000 - .saturating_add((2_369_225_000 as Weight).saturating_mul(t as Weight)) - // Standard Error: 27_000 - .saturating_add((19_831_000 as Weight).saturating_mul(i as Weight)) - // Standard Error: 28_000 - .saturating_add((31_191_000 as Weight).saturating_mul(o as Weight)) + (19_711_861_000 as Weight) + // Standard Error: 55_158_000 + .saturating_add((2_509_755_000 as Weight).saturating_mul(t as Weight)) + // Standard Error: 19_000 + .saturating_add((17_808_000 as Weight).saturating_mul(i as Weight)) + // Standard Error: 21_000 + .saturating_add((28_104_000 as Weight).saturating_mul(o as Weight)) .saturating_add(T::DbWeight::get().reads(105 as Weight)) .saturating_add(T::DbWeight::get().reads((101 as Weight).saturating_mul(t as Weight))) .saturating_add(T::DbWeight::get().writes(101 as Weight)) @@ -654,8 +657,8 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts OwnerInfoOf (r:100 w:100) fn seal_instantiate(r: u32, ) -> Weight { (0 as Weight) - // Standard Error: 50_368_000 - .saturating_add((27_757_564_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 47_294_000 + .saturating_add((26_664_406_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(6 as Weight)) .saturating_add(T::DbWeight::get().reads((400 as Weight).saturating_mul(r as Weight))) .saturating_add(T::DbWeight::get().writes(3 as Weight)) @@ -668,13 +671,13 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts AccountCounter (r:1 w:1) // Storage: Contracts OwnerInfoOf (r:1 w:1) fn seal_instantiate_per_input_output_salt_kb(i: u32, o: u32, s: u32, ) -> Weight { - (25_199_228_000 as Weight) + (24_447_236_000 as Weight) // Standard Error: 36_000 - .saturating_add((19_598_000 as Weight).saturating_mul(i as Weight)) + .saturating_add((18_822_000 as Weight).saturating_mul(i as Weight)) // Standard Error: 36_000 - .saturating_add((30_986_000 as Weight).saturating_mul(o as Weight)) + .saturating_add((28_618_000 as Weight).saturating_mul(o as Weight)) // Standard Error: 36_000 - .saturating_add((158_016_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((156_535_000 as Weight).saturating_mul(s as Weight)) .saturating_add(T::DbWeight::get().reads(208 as Weight)) .saturating_add(T::DbWeight::get().writes(206 as Weight)) } @@ -683,9 +686,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_sha2_256(r: u32, ) -> Weight { - (222_984_000 as Weight) - // Standard Error: 155_000 - .saturating_add((80_649_000 as Weight).saturating_mul(r as Weight)) + (216_091_000 as Weight) + // Standard Error: 123_000 + .saturating_add((79_416_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -694,9 +697,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - (393_726_000 as Weight) - // Standard Error: 36_000 - .saturating_add((463_983_000 as Weight).saturating_mul(n as Weight)) + (223_253_000 as Weight) + // Standard Error: 43_000 + .saturating_add((462_629_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -705,9 +708,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_keccak_256(r: u32, ) -> Weight { - (217_461_000 as Weight) - // Standard Error: 146_000 - .saturating_add((92_540_000 as Weight).saturating_mul(r as Weight)) + (217_285_000 as Weight) + // Standard Error: 147_000 + .saturating_add((91_020_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -716,9 +719,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - (271_742_000 as Weight) - // Standard Error: 19_000 - .saturating_add((307_055_000 as Weight).saturating_mul(n as Weight)) + (364_402_000 as Weight) + // Standard Error: 27_000 + .saturating_add((305_342_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -727,9 +730,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_256(r: u32, ) -> Weight { - (220_664_000 as Weight) - // Standard Error: 145_000 - .saturating_add((64_516_000 as Weight).saturating_mul(r as Weight)) + (214_309_000 as Weight) + // Standard Error: 107_000 + .saturating_add((63_668_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -738,9 +741,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - (287_500_000 as Weight) - // Standard Error: 12_000 - .saturating_add((119_931_000 as Weight).saturating_mul(n as Weight)) + (306_968_000 as Weight) + // Standard Error: 13_000 + .saturating_add((118_373_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -749,9 +752,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_128(r: u32, ) -> Weight { - (214_922_000 as Weight) - // Standard Error: 122_000 - .saturating_add((64_236_000 as Weight).saturating_mul(r as Weight)) + (215_434_000 as Weight) + // Standard Error: 115_000 + .saturating_add((62_560_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -760,9 +763,9 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - (251_648_000 as Weight) - // Standard Error: 13_000 - .saturating_add((120_105_000 as Weight).saturating_mul(n as Weight)) + (226_690_000 as Weight) + // Standard Error: 17_000 + .saturating_add((118_871_000 as Weight).saturating_mul(n as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } @@ -771,266 +774,278 @@ impl WeightInfo for SubstrateWeight { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_ecdsa_recover(r: u32, ) -> Weight { - (124_760_000 as Weight) - // Standard Error: 1_397_000 - .saturating_add((15_387_180_000 as Weight).saturating_mul(r as Weight)) + (187_068_000 as Weight) + // Standard Error: 1_354_000 + .saturating_add((15_409_805_000 as Weight).saturating_mul(r as Weight)) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + // 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: Contracts OwnerInfoOf (r:36 w:36) + fn seal_set_code_hash(r: u32, ) -> Weight { + (0 as Weight) + // Standard Error: 2_158_000 + .saturating_add((932_937_000 as Weight).saturating_mul(r as Weight)) + .saturating_add(T::DbWeight::get().reads((99 as Weight).saturating_mul(r as Weight))) + .saturating_add(T::DbWeight::get().writes((99 as Weight).saturating_mul(r as Weight))) + } fn instr_i64const(r: u32, ) -> Weight { - (75_287_000 as Weight) - // Standard Error: 11_000 - .saturating_add((569_000 as Weight).saturating_mul(r as Weight)) + (74_317_000 as Weight) + // Standard Error: 1_000 + .saturating_add((597_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64load(r: u32, ) -> Weight { - (74_251_000 as Weight) + (74_303_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_306_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_311_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64store(r: u32, ) -> Weight { - (75_072_000 as Weight) - // Standard Error: 4_000 - .saturating_add((1_386_000 as Weight).saturating_mul(r as Weight)) + (74_024_000 as Weight) + // Standard Error: 0 + .saturating_add((1_431_000 as Weight).saturating_mul(r as Weight)) } fn instr_select(r: u32, ) -> Weight { - (73_811_000 as Weight) - // Standard Error: 0 - .saturating_add((1_783_000 as Weight).saturating_mul(r as Weight)) + (74_108_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_778_000 as Weight).saturating_mul(r as Weight)) } fn instr_if(r: u32, ) -> Weight { - (73_901_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_886_000 as Weight).saturating_mul(r as Weight)) + (73_966_000 as Weight) + // Standard Error: 0 + .saturating_add((1_888_000 as Weight).saturating_mul(r as Weight)) } fn instr_br(r: u32, ) -> Weight { - (73_720_000 as Weight) - // Standard Error: 1_000 - .saturating_add((903_000 as Weight).saturating_mul(r as Weight)) + (73_839_000 as Weight) + // Standard Error: 2_000 + .saturating_add((907_000 as Weight).saturating_mul(r as Weight)) } fn instr_br_if(r: u32, ) -> Weight { - (73_534_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_459_000 as Weight).saturating_mul(r as Weight)) + (73_624_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_446_000 as Weight).saturating_mul(r as Weight)) } fn instr_br_table(r: u32, ) -> Weight { - (73_281_000 as Weight) - // Standard Error: 8_000 - .saturating_add((1_584_000 as Weight).saturating_mul(r as Weight)) + (73_169_000 as Weight) + // Standard Error: 5_000 + .saturating_add((1_602_000 as Weight).saturating_mul(r as Weight)) } fn instr_br_table_per_entry(e: u32, ) -> Weight { - (76_135_000 as Weight) - // Standard Error: 1_000 - .saturating_add((6_000 as Weight).saturating_mul(e as Weight)) + (76_328_000 as Weight) + // Standard Error: 0 + .saturating_add((5_000 as Weight).saturating_mul(e as Weight)) } fn instr_call(r: u32, ) -> Weight { - (75_938_000 as Weight) - // Standard Error: 23_000 - .saturating_add((17_156_000 as Weight).saturating_mul(r as Weight)) + (74_771_000 as Weight) + // Standard Error: 22_000 + .saturating_add((17_044_000 as Weight).saturating_mul(r as Weight)) } fn instr_call_indirect(r: u32, ) -> Weight { - (85_864_000 as Weight) - // Standard Error: 28_000 - .saturating_add((28_343_000 as Weight).saturating_mul(r as Weight)) + (90_179_000 as Weight) + // Standard Error: 31_000 + .saturating_add((27_305_000 as Weight).saturating_mul(r as Weight)) } fn instr_call_indirect_per_param(p: u32, ) -> Weight { - (119_795_000 as Weight) - // Standard Error: 1_000 - .saturating_add((911_000 as Weight).saturating_mul(p as Weight)) + (117_977_000 as Weight) + // Standard Error: 2_000 + .saturating_add((928_000 as Weight).saturating_mul(p as Weight)) } fn instr_local_get(r: u32, ) -> Weight { - (74_750_000 as Weight) + (75_093_000 as Weight) // Standard Error: 1_000 - .saturating_add((613_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((610_000 as Weight).saturating_mul(r as Weight)) } fn instr_local_set(r: u32, ) -> Weight { - (74_831_000 as Weight) - // Standard Error: 2_000 - .saturating_add((672_000 as Weight).saturating_mul(r as Weight)) + (74_793_000 as Weight) + // Standard Error: 1_000 + .saturating_add((676_000 as Weight).saturating_mul(r as Weight)) } fn instr_local_tee(r: u32, ) -> Weight { - (74_314_000 as Weight) - // Standard Error: 1_000 - .saturating_add((902_000 as Weight).saturating_mul(r as Weight)) + (74_183_000 as Weight) + // Standard Error: 2_000 + .saturating_add((913_000 as Weight).saturating_mul(r as Weight)) } fn instr_global_get(r: u32, ) -> Weight { - (77_040_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_161_000 as Weight).saturating_mul(r as Weight)) + (77_079_000 as Weight) + // Standard Error: 2_000 + .saturating_add((1_156_000 as Weight).saturating_mul(r as Weight)) } fn instr_global_set(r: u32, ) -> Weight { - (76_770_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_372_000 as Weight).saturating_mul(r as Weight)) + (77_063_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) } fn instr_memory_current(r: u32, ) -> Weight { - (74_010_000 as Weight) - // Standard Error: 1_000 - .saturating_add((665_000 as Weight).saturating_mul(r as Weight)) + (74_314_000 as Weight) + // Standard Error: 2_000 + .saturating_add((662_000 as Weight).saturating_mul(r as Weight)) } fn instr_memory_grow(r: u32, ) -> Weight { - (73_597_000 as Weight) - // Standard Error: 929_000 - .saturating_add((183_940_000 as Weight).saturating_mul(r as Weight)) + (73_585_000 as Weight) + // Standard Error: 2_291_000 + .saturating_add((174_749_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64clz(r: u32, ) -> Weight { - (74_488_000 as Weight) - // Standard Error: 4_000 - .saturating_add((893_000 as Weight).saturating_mul(r as Weight)) + (74_062_000 as Weight) + // Standard Error: 2_000 + .saturating_add((905_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ctz(r: u32, ) -> Weight { - (74_024_000 as Weight) - // Standard Error: 5_000 - .saturating_add((908_000 as Weight).saturating_mul(r as Weight)) + (74_121_000 as Weight) + // Standard Error: 1_000 + .saturating_add((903_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64popcnt(r: u32, ) -> Weight { - (74_084_000 as Weight) - // Standard Error: 1_000 - .saturating_add((895_000 as Weight).saturating_mul(r as Weight)) + (74_519_000 as Weight) + // Standard Error: 2_000 + .saturating_add((885_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64eqz(r: u32, ) -> Weight { - (74_250_000 as Weight) - // Standard Error: 2_000 - .saturating_add((916_000 as Weight).saturating_mul(r as Weight)) + (74_357_000 as Weight) + // Standard Error: 1_000 + .saturating_add((914_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64extendsi32(r: u32, ) -> Weight { - (74_027_000 as Weight) + (74_101_000 as Weight) // Standard Error: 1_000 - .saturating_add((883_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((885_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64extendui32(r: u32, ) -> Weight { - (74_201_000 as Weight) + (74_442_000 as Weight) // Standard Error: 1_000 - .saturating_add((879_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((875_000 as Weight).saturating_mul(r as Weight)) } fn instr_i32wrapi64(r: u32, ) -> Weight { - (74_116_000 as Weight) + (74_247_000 as Weight) // Standard Error: 1_000 - .saturating_add((892_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((891_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64eq(r: u32, ) -> Weight { - (74_109_000 as Weight) + (74_091_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_358_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ne(r: u32, ) -> Weight { - (73_962_000 as Weight) + (74_178_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_358_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64lts(r: u32, ) -> Weight { - (73_977_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_360_000 as Weight).saturating_mul(r as Weight)) + (74_370_000 as Weight) + // Standard Error: 2_000 + .saturating_add((1_353_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ltu(r: u32, ) -> Weight { - (74_046_000 as Weight) + (74_180_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_360_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_356_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64gts(r: u32, ) -> Weight { - (73_912_000 as Weight) - // Standard Error: 0 - .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) + (74_035_000 as Weight) + // Standard Error: 3_000 + .saturating_add((1_365_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64gtu(r: u32, ) -> Weight { - (73_918_000 as Weight) + (74_538_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_367_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_357_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64les(r: u32, ) -> Weight { - (73_953_000 as Weight) + (74_035_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_368_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64leu(r: u32, ) -> Weight { - (74_855_000 as Weight) - // Standard Error: 4_000 - .saturating_add((1_347_000 as Weight).saturating_mul(r as Weight)) + (74_399_000 as Weight) + // Standard Error: 8_000 + .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ges(r: u32, ) -> Weight { - (73_917_000 as Weight) - // Standard Error: 2_000 + (73_987_000 as Weight) + // Standard Error: 1_000 .saturating_add((1_364_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64geu(r: u32, ) -> Weight { - (73_949_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_361_000 as Weight).saturating_mul(r as Weight)) + (74_017_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_366_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64add(r: u32, ) -> Weight { - (73_726_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_347_000 as Weight).saturating_mul(r as Weight)) + (74_271_000 as Weight) + // Standard Error: 2_000 + .saturating_add((1_330_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64sub(r: u32, ) -> Weight { - (73_921_000 as Weight) - // Standard Error: 1_000 + (74_016_000 as Weight) + // Standard Error: 0 .saturating_add((1_345_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64mul(r: u32, ) -> Weight { - (73_924_000 as Weight) + (74_063_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_341_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_338_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64divs(r: u32, ) -> Weight { - (73_842_000 as Weight) - // Standard Error: 2_000 - .saturating_add((2_011_000 as Weight).saturating_mul(r as Weight)) + (74_094_000 as Weight) + // Standard Error: 1_000 + .saturating_add((2_002_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64divu(r: u32, ) -> Weight { - (73_932_000 as Weight) - // Standard Error: 1_000 - .saturating_add((2_057_000 as Weight).saturating_mul(r as Weight)) + (73_957_000 as Weight) + // Standard Error: 2_000 + .saturating_add((2_045_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64rems(r: u32, ) -> Weight { - (74_028_000 as Weight) + (74_067_000 as Weight) // Standard Error: 2_000 - .saturating_add((2_001_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_975_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64remu(r: u32, ) -> Weight { - (73_784_000 as Weight) - // Standard Error: 2_000 - .saturating_add((2_059_000 as Weight).saturating_mul(r as Weight)) + (74_092_000 as Weight) + // Standard Error: 1_000 + .saturating_add((2_035_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64and(r: u32, ) -> Weight { - (74_169_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_334_000 as Weight).saturating_mul(r as Weight)) + (74_059_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_338_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64or(r: u32, ) -> Weight { - (73_982_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_340_000 as Weight).saturating_mul(r as Weight)) + (74_122_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_335_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64xor(r: u32, ) -> Weight { - (74_310_000 as Weight) + (74_296_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_329_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_333_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64shl(r: u32, ) -> Weight { - (73_861_000 as Weight) + (73_810_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_368_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64shrs(r: u32, ) -> Weight { - (73_787_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_364_000 as Weight).saturating_mul(r as Weight)) + (74_101_000 as Weight) + // Standard Error: 9_000 + .saturating_add((1_407_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64shru(r: u32, ) -> Weight { - (73_886_000 as Weight) - // Standard Error: 7_000 - .saturating_add((1_372_000 as Weight).saturating_mul(r as Weight)) + (74_076_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_353_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64rotl(r: u32, ) -> Weight { - (73_860_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) + (74_082_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_354_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64rotr(r: u32, ) -> Weight { - (73_917_000 as Weight) + (74_054_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_356_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_355_000 as Weight).saturating_mul(r as Weight)) } } @@ -1038,32 +1053,32 @@ impl WeightInfo for SubstrateWeight { impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:0) fn on_initialize() -> Weight { - (1_640_000 as Weight) + (1_590_000 as Weight) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn on_initialize_per_trie_key(k: u32, ) -> Weight { - (6_385_000 as Weight) + (9_975_000 as Weight) // Standard Error: 0 - .saturating_add((748_000 as Weight).saturating_mul(k as Weight)) + .saturating_add((724_000 as Weight).saturating_mul(k as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) .saturating_add(RocksDbWeight::get().writes((1 as Weight).saturating_mul(k as Weight))) } // Storage: Contracts DeletionQueue (r:1 w:0) fn on_initialize_per_queue_item(q: u32, ) -> Weight { - (0 as Weight) - // Standard Error: 5_000 - .saturating_add((2_304_000 as Weight).saturating_mul(q as Weight)) + (7_415_000 as Weight) + // Standard Error: 4_000 + .saturating_add((2_303_000 as Weight).saturating_mul(q as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Contracts PristineCode (r:1 w:0) // Storage: Contracts CodeStorage (r:0 w:1) fn reinstrument(c: u32, ) -> Weight { - (22_923_000 as Weight) - // Standard Error: 33_000 - .saturating_add((65_851_000 as Weight).saturating_mul(c as Weight)) + (18_519_000 as Weight) + // Standard Error: 36_000 + .saturating_add((66_661_000 as Weight).saturating_mul(c as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1072,9 +1087,9 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System Account (r:1 w:1) fn call_with_code_kb(c: u32, ) -> Weight { - (209_577_000 as Weight) - // Standard Error: 53_000 - .saturating_add((61_341_000 as Weight).saturating_mul(c as Weight)) + (210_319_000 as Weight) + // Standard Error: 41_000 + .saturating_add((54_802_000 as Weight).saturating_mul(c as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } @@ -1086,11 +1101,11 @@ impl WeightInfo for () { // Storage: Contracts PristineCode (r:0 w:1) // Storage: Contracts OwnerInfoOf (r:0 w:1) fn instantiate_with_code(c: u32, s: u32, ) -> Weight { - (240_302_000 as Weight) - // Standard Error: 119_000 - .saturating_add((151_894_000 as Weight).saturating_mul(c as Weight)) - // Standard Error: 7_000 - .saturating_add((1_740_000 as Weight).saturating_mul(s as Weight)) + (220_394_000 as Weight) + // Standard Error: 129_000 + .saturating_add((145_155_000 as Weight).saturating_mul(c as Weight)) + // Standard Error: 8_000 + .saturating_add((1_741_000 as Weight).saturating_mul(s as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(6 as Weight)) } @@ -1101,9 +1116,9 @@ impl WeightInfo for () { // Storage: System Account (r:1 w:1) // Storage: Contracts OwnerInfoOf (r:1 w:1) fn instantiate(s: u32, ) -> Weight { - (172_047_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_729_000 as Weight).saturating_mul(s as Weight)) + (171_438_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_721_000 as Weight).saturating_mul(s as Weight)) .saturating_add(RocksDbWeight::get().reads(6 as Weight)) .saturating_add(RocksDbWeight::get().writes(5 as Weight)) } @@ -1112,7 +1127,7 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System Account (r:1 w:1) fn call() -> Weight { - (139_349_000 as Weight) + (139_529_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } @@ -1120,9 +1135,9 @@ impl WeightInfo for () { // Storage: Contracts PristineCode (r:0 w:1) // Storage: Contracts OwnerInfoOf (r:0 w:1) fn upload_code(c: u32, ) -> Weight { - (50_449_000 as Weight) - // Standard Error: 45_000 - .saturating_add((68_254_000 as Weight).saturating_mul(c as Weight)) + (51_040_000 as Weight) + // Standard Error: 38_000 + .saturating_add((65_886_000 as Weight).saturating_mul(c as Weight)) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) } @@ -1130,7 +1145,7 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:0 w:1) // Storage: Contracts PristineCode (r:0 w:1) fn remove_code() -> Weight { - (24_576_000 as Weight) + (24_347_000 as Weight) .saturating_add(RocksDbWeight::get().reads(1 as Weight)) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) } @@ -1139,9 +1154,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_caller(r: u32, ) -> Weight { - (220_059_000 as Weight) - // Standard Error: 128_000 - .saturating_add((49_607_000 as Weight).saturating_mul(r as Weight)) + (217_164_000 as Weight) + // Standard Error: 89_000 + .saturating_add((48_023_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1150,9 +1165,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_is_contract(r: u32, ) -> Weight { - (84_138_000 as Weight) - // Standard Error: 896_000 - .saturating_add((375_553_000 as Weight).saturating_mul(r as Weight)) + (81_537_000 as Weight) + // Standard Error: 847_000 + .saturating_add((367_429_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -1162,9 +1177,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_caller_is_origin(r: u32, ) -> Weight { - (222_496_000 as Weight) - // Standard Error: 119_000 - .saturating_add((22_340_000 as Weight).saturating_mul(r as Weight)) + (214_798_000 as Weight) + // Standard Error: 56_000 + .saturating_add((21_100_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1173,9 +1188,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_address(r: u32, ) -> Weight { - (221_446_000 as Weight) - // Standard Error: 131_000 - .saturating_add((49_401_000 as Weight).saturating_mul(r as Weight)) + (216_615_000 as Weight) + // Standard Error: 75_000 + .saturating_add((48_054_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1184,9 +1199,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_gas_left(r: u32, ) -> Weight { - (220_964_000 as Weight) - // Standard Error: 132_000 - .saturating_add((49_230_000 as Weight).saturating_mul(r as Weight)) + (218_034_000 as Weight) + // Standard Error: 87_000 + .saturating_add((47_594_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1195,9 +1210,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_balance(r: u32, ) -> Weight { - (229_399_000 as Weight) - // Standard Error: 166_000 - .saturating_add((137_407_000 as Weight).saturating_mul(r as Weight)) + (221_980_000 as Weight) + // Standard Error: 135_000 + .saturating_add((135_618_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1206,9 +1221,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_value_transferred(r: u32, ) -> Weight { - (220_103_000 as Weight) - // Standard Error: 133_000 - .saturating_add((49_410_000 as Weight).saturating_mul(r as Weight)) + (217_623_000 as Weight) + // Standard Error: 86_000 + .saturating_add((47_656_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1217,9 +1232,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_minimum_balance(r: u32, ) -> Weight { - (228_143_000 as Weight) - // Standard Error: 151_000 - .saturating_add((48_608_000 as Weight).saturating_mul(r as Weight)) + (216_826_000 as Weight) + // Standard Error: 88_000 + .saturating_add((47_644_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1228,9 +1243,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_block_number(r: u32, ) -> Weight { - (223_899_000 as Weight) - // Standard Error: 142_000 - .saturating_add((48_841_000 as Weight).saturating_mul(r as Weight)) + (219_487_000 as Weight) + // Standard Error: 90_000 + .saturating_add((47_167_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1239,9 +1254,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_now(r: u32, ) -> Weight { - (224_974_000 as Weight) - // Standard Error: 148_000 - .saturating_add((48_902_000 as Weight).saturating_mul(r as Weight)) + (218_953_000 as Weight) + // Standard Error: 95_000 + .saturating_add((47_458_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1251,9 +1266,9 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: TransactionPayment NextFeeMultiplier (r:1 w:0) fn seal_weight_to_fee(r: u32, ) -> Weight { - (227_556_000 as Weight) - // Standard Error: 151_000 - .saturating_add((121_252_000 as Weight).saturating_mul(r as Weight)) + (220_132_000 as Weight) + // Standard Error: 144_000 + .saturating_add((120_373_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1262,9 +1277,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_gas(r: u32, ) -> Weight { - (127_975_000 as Weight) - // Standard Error: 57_000 - .saturating_add((24_843_000 as Weight).saturating_mul(r as Weight)) + (127_458_000 as Weight) + // Standard Error: 56_000 + .saturating_add((24_015_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1273,9 +1288,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_input(r: u32, ) -> Weight { - (224_592_000 as Weight) - // Standard Error: 141_000 - .saturating_add((48_296_000 as Weight).saturating_mul(r as Weight)) + (220_304_000 as Weight) + // Standard Error: 112_000 + .saturating_add((46_804_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1284,9 +1299,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_input_per_kb(n: u32, ) -> Weight { - (296_995_000 as Weight) - // Standard Error: 3_000 - .saturating_add((11_884_000 as Weight).saturating_mul(n as Weight)) + (300_916_000 as Weight) + // Standard Error: 8_000 + .saturating_add((10_552_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1294,8 +1309,10 @@ impl WeightInfo for () { // Storage: Contracts ContractInfoOf (r:1 w:1) // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) - fn seal_return(_r: u32, ) -> Weight { - (224_322_000 as Weight) + fn seal_return(r: u32, ) -> Weight { + (211_812_000 as Weight) + // Standard Error: 138_000 + .saturating_add((1_698_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1304,9 +1321,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_return_per_kb(n: u32, ) -> Weight { - (216_240_000 as Weight) - // Standard Error: 1_000 - .saturating_add((206_000 as Weight).saturating_mul(n as Weight)) + (213_994_000 as Weight) + // Standard Error: 0 + .saturating_add((176_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1317,9 +1334,9 @@ impl WeightInfo for () { // Storage: Contracts DeletionQueue (r:1 w:1) // Storage: Contracts OwnerInfoOf (r:1 w:1) fn seal_terminate(r: u32, ) -> Weight { - (219_637_000 as Weight) - // Standard Error: 3_916_000 - .saturating_add((51_769_000 as Weight).saturating_mul(r as Weight)) + (215_173_000 as Weight) + // Standard Error: 708_000 + .saturating_add((52_509_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().reads((4 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -1331,9 +1348,9 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0) fn seal_random(r: u32, ) -> Weight { - (221_470_000 as Weight) - // Standard Error: 154_000 - .saturating_add((158_758_000 as Weight).saturating_mul(r as Weight)) + (219_521_000 as Weight) + // Standard Error: 171_000 + .saturating_add((156_228_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1342,9 +1359,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_deposit_event(r: u32, ) -> Weight { - (228_674_000 as Weight) - // Standard Error: 203_000 - .saturating_add((287_195_000 as Weight).saturating_mul(r as Weight)) + (227_624_000 as Weight) + // Standard Error: 193_000 + .saturating_add((285_058_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1354,11 +1371,11 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) // Storage: System EventTopics (r:100 w:100) fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight { - (507_091_000 as Weight) - // Standard Error: 1_863_000 - .saturating_add((291_858_000 as Weight).saturating_mul(t as Weight)) - // Standard Error: 367_000 - .saturating_add((83_459_000 as Weight).saturating_mul(n as Weight)) + (503_312_000 as Weight) + // Standard Error: 1_729_000 + .saturating_add((288_009_000 as Weight).saturating_mul(t as Weight)) + // Standard Error: 340_000 + .saturating_add((80_936_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(t as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -1369,17 +1386,17 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_debug_message(r: u32, ) -> Weight { - (133_592_000 as Weight) - // Standard Error: 87_000 - .saturating_add((41_718_000 as Weight).saturating_mul(r as Weight)) + (132_096_000 as Weight) + // Standard Error: 73_000 + .saturating_add((40_337_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_set_storage(r: u32, ) -> Weight { - (44_719_000 as Weight) - // Standard Error: 1_036_000 - .saturating_add((407_521_000 as Weight).saturating_mul(r as Weight)) + (52_622_000 as Weight) + // Standard Error: 1_006_000 + .saturating_add((404_716_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -1387,25 +1404,25 @@ impl WeightInfo for () { } // Storage: Skipped Metadata (r:0 w:0) fn seal_set_storage_per_new_kb(n: u32, ) -> Weight { - (606_108_000 as Weight) - // Standard Error: 315_000 - .saturating_add((29_136_000 as Weight).saturating_mul(n as Weight)) + (601_324_000 as Weight) + // Standard Error: 264_000 + .saturating_add((27_943_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(105 as Weight)) .saturating_add(RocksDbWeight::get().writes(103 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_set_storage_per_old_kb(n: u32, ) -> Weight { - (634_330_000 as Weight) - // Standard Error: 281_000 - .saturating_add((10_741_000 as Weight).saturating_mul(n as Weight)) + (626_752_000 as Weight) + // Standard Error: 292_000 + .saturating_add((10_616_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(105 as Weight)) .saturating_add(RocksDbWeight::get().writes(103 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_clear_storage(r: u32, ) -> Weight { - (89_750_000 as Weight) - // Standard Error: 924_000 - .saturating_add((382_525_000 as Weight).saturating_mul(r as Weight)) + (80_138_000 as Weight) + // Standard Error: 933_000 + .saturating_add((382_949_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) @@ -1413,51 +1430,51 @@ impl WeightInfo for () { } // Storage: Skipped Metadata (r:0 w:0) fn seal_clear_storage_per_kb(n: u32, ) -> Weight { - (616_463_000 as Weight) - // Standard Error: 260_000 - .saturating_add((10_373_000 as Weight).saturating_mul(n as Weight)) + (603_984_000 as Weight) + // Standard Error: 242_000 + .saturating_add((10_712_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(105 as Weight)) .saturating_add(RocksDbWeight::get().writes(103 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_get_storage(r: u32, ) -> Weight { - (116_340_000 as Weight) - // Standard Error: 633_000 - .saturating_add((322_054_000 as Weight).saturating_mul(r as Weight)) + (113_136_000 as Weight) + // Standard Error: 635_000 + .saturating_add((324_706_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_get_storage_per_kb(n: u32, ) -> Weight { - (563_077_000 as Weight) - // Standard Error: 340_000 - .saturating_add((63_889_000 as Weight).saturating_mul(n as Weight)) + (562_781_000 as Weight) + // Standard Error: 354_000 + .saturating_add((63_275_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(104 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_contains_storage(r: u32, ) -> Weight { - (118_832_000 as Weight) - // Standard Error: 595_000 - .saturating_add((291_817_000 as Weight).saturating_mul(r as Weight)) + (112_237_000 as Weight) + // Standard Error: 655_000 + .saturating_add((296_653_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_contains_storage_per_kb(n: u32, ) -> Weight { - (520_386_000 as Weight) - // Standard Error: 297_000 - .saturating_add((10_076_000 as Weight).saturating_mul(n as Weight)) + (520_002_000 as Weight) + // Standard Error: 232_000 + .saturating_add((9_726_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(104 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } // Storage: Skipped Metadata (r:0 w:0) fn seal_take_storage(r: u32, ) -> Weight { - (85_377_000 as Weight) - // Standard Error: 847_000 - .saturating_add((419_438_000 as Weight).saturating_mul(r as Weight)) + (87_232_000 as Weight) + // Standard Error: 920_000 + .saturating_add((415_305_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) @@ -1465,9 +1482,9 @@ impl WeightInfo for () { } // Storage: Skipped Metadata (r:0 w:0) fn seal_take_storage_per_kb(n: u32, ) -> Weight { - (666_218_000 as Weight) - // Standard Error: 294_000 - .saturating_add((64_627_000 as Weight).saturating_mul(n as Weight)) + (648_862_000 as Weight) + // Standard Error: 319_000 + .saturating_add((63_991_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(105 as Weight)) .saturating_add(RocksDbWeight::get().writes(103 as Weight)) } @@ -1476,9 +1493,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_transfer(r: u32, ) -> Weight { - (108_224_000 as Weight) - // Standard Error: 1_042_000 - .saturating_add((1_723_539_000 as Weight).saturating_mul(r as Weight)) + (99_621_000 as Weight) + // Standard Error: 1_154_000 + .saturating_add((1_732_052_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) @@ -1490,8 +1507,8 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) fn seal_call(r: u32, ) -> Weight { (0 as Weight) - // Standard Error: 7_843_000 - .saturating_add((19_825_093_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 6_293_000 + .saturating_add((19_410_115_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().reads((100 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) @@ -1503,8 +1520,8 @@ impl WeightInfo for () { // Storage: Timestamp Now (r:1 w:0) fn seal_delegate_call(r: u32, ) -> Weight { (0 as Weight) - // Standard Error: 11_788_000 - .saturating_add((19_855_594_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 7_155_000 + .saturating_add((19_793_614_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads((99 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1513,13 +1530,13 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:2 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_call_per_transfer_input_output_kb(t: u32, i: u32, o: u32, ) -> Weight { - (20_190_331_000 as Weight) - // Standard Error: 75_647_000 - .saturating_add((2_369_225_000 as Weight).saturating_mul(t as Weight)) - // Standard Error: 27_000 - .saturating_add((19_831_000 as Weight).saturating_mul(i as Weight)) - // Standard Error: 28_000 - .saturating_add((31_191_000 as Weight).saturating_mul(o as Weight)) + (19_711_861_000 as Weight) + // Standard Error: 55_158_000 + .saturating_add((2_509_755_000 as Weight).saturating_mul(t as Weight)) + // Standard Error: 19_000 + .saturating_add((17_808_000 as Weight).saturating_mul(i as Weight)) + // Standard Error: 21_000 + .saturating_add((28_104_000 as Weight).saturating_mul(o as Weight)) .saturating_add(RocksDbWeight::get().reads(105 as Weight)) .saturating_add(RocksDbWeight::get().reads((101 as Weight).saturating_mul(t as Weight))) .saturating_add(RocksDbWeight::get().writes(101 as Weight)) @@ -1533,8 +1550,8 @@ impl WeightInfo for () { // Storage: Contracts OwnerInfoOf (r:100 w:100) fn seal_instantiate(r: u32, ) -> Weight { (0 as Weight) - // Standard Error: 50_368_000 - .saturating_add((27_757_564_000 as Weight).saturating_mul(r as Weight)) + // Standard Error: 47_294_000 + .saturating_add((26_664_406_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(6 as Weight)) .saturating_add(RocksDbWeight::get().reads((400 as Weight).saturating_mul(r as Weight))) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) @@ -1547,13 +1564,13 @@ impl WeightInfo for () { // Storage: Contracts AccountCounter (r:1 w:1) // Storage: Contracts OwnerInfoOf (r:1 w:1) fn seal_instantiate_per_input_output_salt_kb(i: u32, o: u32, s: u32, ) -> Weight { - (25_199_228_000 as Weight) + (24_447_236_000 as Weight) // Standard Error: 36_000 - .saturating_add((19_598_000 as Weight).saturating_mul(i as Weight)) + .saturating_add((18_822_000 as Weight).saturating_mul(i as Weight)) // Standard Error: 36_000 - .saturating_add((30_986_000 as Weight).saturating_mul(o as Weight)) + .saturating_add((28_618_000 as Weight).saturating_mul(o as Weight)) // Standard Error: 36_000 - .saturating_add((158_016_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((156_535_000 as Weight).saturating_mul(s as Weight)) .saturating_add(RocksDbWeight::get().reads(208 as Weight)) .saturating_add(RocksDbWeight::get().writes(206 as Weight)) } @@ -1562,9 +1579,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_sha2_256(r: u32, ) -> Weight { - (222_984_000 as Weight) - // Standard Error: 155_000 - .saturating_add((80_649_000 as Weight).saturating_mul(r as Weight)) + (216_091_000 as Weight) + // Standard Error: 123_000 + .saturating_add((79_416_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1573,9 +1590,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight { - (393_726_000 as Weight) - // Standard Error: 36_000 - .saturating_add((463_983_000 as Weight).saturating_mul(n as Weight)) + (223_253_000 as Weight) + // Standard Error: 43_000 + .saturating_add((462_629_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1584,9 +1601,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_keccak_256(r: u32, ) -> Weight { - (217_461_000 as Weight) - // Standard Error: 146_000 - .saturating_add((92_540_000 as Weight).saturating_mul(r as Weight)) + (217_285_000 as Weight) + // Standard Error: 147_000 + .saturating_add((91_020_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1595,9 +1612,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight { - (271_742_000 as Weight) - // Standard Error: 19_000 - .saturating_add((307_055_000 as Weight).saturating_mul(n as Weight)) + (364_402_000 as Weight) + // Standard Error: 27_000 + .saturating_add((305_342_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1606,9 +1623,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_256(r: u32, ) -> Weight { - (220_664_000 as Weight) - // Standard Error: 145_000 - .saturating_add((64_516_000 as Weight).saturating_mul(r as Weight)) + (214_309_000 as Weight) + // Standard Error: 107_000 + .saturating_add((63_668_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1617,9 +1634,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight { - (287_500_000 as Weight) - // Standard Error: 12_000 - .saturating_add((119_931_000 as Weight).saturating_mul(n as Weight)) + (306_968_000 as Weight) + // Standard Error: 13_000 + .saturating_add((118_373_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1628,9 +1645,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_128(r: u32, ) -> Weight { - (214_922_000 as Weight) - // Standard Error: 122_000 - .saturating_add((64_236_000 as Weight).saturating_mul(r as Weight)) + (215_434_000 as Weight) + // Standard Error: 115_000 + .saturating_add((62_560_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1639,9 +1656,9 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight { - (251_648_000 as Weight) - // Standard Error: 13_000 - .saturating_add((120_105_000 as Weight).saturating_mul(n as Weight)) + (226_690_000 as Weight) + // Standard Error: 17_000 + .saturating_add((118_871_000 as Weight).saturating_mul(n as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } @@ -1650,265 +1667,277 @@ impl WeightInfo for () { // Storage: Contracts CodeStorage (r:1 w:0) // Storage: Timestamp Now (r:1 w:0) fn seal_ecdsa_recover(r: u32, ) -> Weight { - (124_760_000 as Weight) - // Standard Error: 1_397_000 - .saturating_add((15_387_180_000 as Weight).saturating_mul(r as Weight)) + (187_068_000 as Weight) + // Standard Error: 1_354_000 + .saturating_add((15_409_805_000 as Weight).saturating_mul(r as Weight)) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + // 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: Contracts OwnerInfoOf (r:36 w:36) + fn seal_set_code_hash(r: u32, ) -> Weight { + (0 as Weight) + // Standard Error: 2_158_000 + .saturating_add((932_937_000 as Weight).saturating_mul(r as Weight)) + .saturating_add(RocksDbWeight::get().reads((99 as Weight).saturating_mul(r as Weight))) + .saturating_add(RocksDbWeight::get().writes((99 as Weight).saturating_mul(r as Weight))) + } fn instr_i64const(r: u32, ) -> Weight { - (75_287_000 as Weight) - // Standard Error: 11_000 - .saturating_add((569_000 as Weight).saturating_mul(r as Weight)) + (74_317_000 as Weight) + // Standard Error: 1_000 + .saturating_add((597_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64load(r: u32, ) -> Weight { - (74_251_000 as Weight) + (74_303_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_306_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_311_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64store(r: u32, ) -> Weight { - (75_072_000 as Weight) - // Standard Error: 4_000 - .saturating_add((1_386_000 as Weight).saturating_mul(r as Weight)) + (74_024_000 as Weight) + // Standard Error: 0 + .saturating_add((1_431_000 as Weight).saturating_mul(r as Weight)) } fn instr_select(r: u32, ) -> Weight { - (73_811_000 as Weight) - // Standard Error: 0 - .saturating_add((1_783_000 as Weight).saturating_mul(r as Weight)) + (74_108_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_778_000 as Weight).saturating_mul(r as Weight)) } fn instr_if(r: u32, ) -> Weight { - (73_901_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_886_000 as Weight).saturating_mul(r as Weight)) + (73_966_000 as Weight) + // Standard Error: 0 + .saturating_add((1_888_000 as Weight).saturating_mul(r as Weight)) } fn instr_br(r: u32, ) -> Weight { - (73_720_000 as Weight) - // Standard Error: 1_000 - .saturating_add((903_000 as Weight).saturating_mul(r as Weight)) + (73_839_000 as Weight) + // Standard Error: 2_000 + .saturating_add((907_000 as Weight).saturating_mul(r as Weight)) } fn instr_br_if(r: u32, ) -> Weight { - (73_534_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_459_000 as Weight).saturating_mul(r as Weight)) + (73_624_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_446_000 as Weight).saturating_mul(r as Weight)) } fn instr_br_table(r: u32, ) -> Weight { - (73_281_000 as Weight) - // Standard Error: 8_000 - .saturating_add((1_584_000 as Weight).saturating_mul(r as Weight)) + (73_169_000 as Weight) + // Standard Error: 5_000 + .saturating_add((1_602_000 as Weight).saturating_mul(r as Weight)) } fn instr_br_table_per_entry(e: u32, ) -> Weight { - (76_135_000 as Weight) - // Standard Error: 1_000 - .saturating_add((6_000 as Weight).saturating_mul(e as Weight)) + (76_328_000 as Weight) + // Standard Error: 0 + .saturating_add((5_000 as Weight).saturating_mul(e as Weight)) } fn instr_call(r: u32, ) -> Weight { - (75_938_000 as Weight) - // Standard Error: 23_000 - .saturating_add((17_156_000 as Weight).saturating_mul(r as Weight)) + (74_771_000 as Weight) + // Standard Error: 22_000 + .saturating_add((17_044_000 as Weight).saturating_mul(r as Weight)) } fn instr_call_indirect(r: u32, ) -> Weight { - (85_864_000 as Weight) - // Standard Error: 28_000 - .saturating_add((28_343_000 as Weight).saturating_mul(r as Weight)) + (90_179_000 as Weight) + // Standard Error: 31_000 + .saturating_add((27_305_000 as Weight).saturating_mul(r as Weight)) } fn instr_call_indirect_per_param(p: u32, ) -> Weight { - (119_795_000 as Weight) - // Standard Error: 1_000 - .saturating_add((911_000 as Weight).saturating_mul(p as Weight)) + (117_977_000 as Weight) + // Standard Error: 2_000 + .saturating_add((928_000 as Weight).saturating_mul(p as Weight)) } fn instr_local_get(r: u32, ) -> Weight { - (74_750_000 as Weight) + (75_093_000 as Weight) // Standard Error: 1_000 - .saturating_add((613_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((610_000 as Weight).saturating_mul(r as Weight)) } fn instr_local_set(r: u32, ) -> Weight { - (74_831_000 as Weight) - // Standard Error: 2_000 - .saturating_add((672_000 as Weight).saturating_mul(r as Weight)) + (74_793_000 as Weight) + // Standard Error: 1_000 + .saturating_add((676_000 as Weight).saturating_mul(r as Weight)) } fn instr_local_tee(r: u32, ) -> Weight { - (74_314_000 as Weight) - // Standard Error: 1_000 - .saturating_add((902_000 as Weight).saturating_mul(r as Weight)) + (74_183_000 as Weight) + // Standard Error: 2_000 + .saturating_add((913_000 as Weight).saturating_mul(r as Weight)) } fn instr_global_get(r: u32, ) -> Weight { - (77_040_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_161_000 as Weight).saturating_mul(r as Weight)) + (77_079_000 as Weight) + // Standard Error: 2_000 + .saturating_add((1_156_000 as Weight).saturating_mul(r as Weight)) } fn instr_global_set(r: u32, ) -> Weight { - (76_770_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_372_000 as Weight).saturating_mul(r as Weight)) + (77_063_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) } fn instr_memory_current(r: u32, ) -> Weight { - (74_010_000 as Weight) - // Standard Error: 1_000 - .saturating_add((665_000 as Weight).saturating_mul(r as Weight)) + (74_314_000 as Weight) + // Standard Error: 2_000 + .saturating_add((662_000 as Weight).saturating_mul(r as Weight)) } fn instr_memory_grow(r: u32, ) -> Weight { - (73_597_000 as Weight) - // Standard Error: 929_000 - .saturating_add((183_940_000 as Weight).saturating_mul(r as Weight)) + (73_585_000 as Weight) + // Standard Error: 2_291_000 + .saturating_add((174_749_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64clz(r: u32, ) -> Weight { - (74_488_000 as Weight) - // Standard Error: 4_000 - .saturating_add((893_000 as Weight).saturating_mul(r as Weight)) + (74_062_000 as Weight) + // Standard Error: 2_000 + .saturating_add((905_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ctz(r: u32, ) -> Weight { - (74_024_000 as Weight) - // Standard Error: 5_000 - .saturating_add((908_000 as Weight).saturating_mul(r as Weight)) + (74_121_000 as Weight) + // Standard Error: 1_000 + .saturating_add((903_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64popcnt(r: u32, ) -> Weight { - (74_084_000 as Weight) - // Standard Error: 1_000 - .saturating_add((895_000 as Weight).saturating_mul(r as Weight)) + (74_519_000 as Weight) + // Standard Error: 2_000 + .saturating_add((885_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64eqz(r: u32, ) -> Weight { - (74_250_000 as Weight) - // Standard Error: 2_000 - .saturating_add((916_000 as Weight).saturating_mul(r as Weight)) + (74_357_000 as Weight) + // Standard Error: 1_000 + .saturating_add((914_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64extendsi32(r: u32, ) -> Weight { - (74_027_000 as Weight) + (74_101_000 as Weight) // Standard Error: 1_000 - .saturating_add((883_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((885_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64extendui32(r: u32, ) -> Weight { - (74_201_000 as Weight) + (74_442_000 as Weight) // Standard Error: 1_000 - .saturating_add((879_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((875_000 as Weight).saturating_mul(r as Weight)) } fn instr_i32wrapi64(r: u32, ) -> Weight { - (74_116_000 as Weight) + (74_247_000 as Weight) // Standard Error: 1_000 - .saturating_add((892_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((891_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64eq(r: u32, ) -> Weight { - (74_109_000 as Weight) + (74_091_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_358_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ne(r: u32, ) -> Weight { - (73_962_000 as Weight) + (74_178_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_358_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64lts(r: u32, ) -> Weight { - (73_977_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_360_000 as Weight).saturating_mul(r as Weight)) + (74_370_000 as Weight) + // Standard Error: 2_000 + .saturating_add((1_353_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ltu(r: u32, ) -> Weight { - (74_046_000 as Weight) + (74_180_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_360_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_356_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64gts(r: u32, ) -> Weight { - (73_912_000 as Weight) - // Standard Error: 0 - .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) + (74_035_000 as Weight) + // Standard Error: 3_000 + .saturating_add((1_365_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64gtu(r: u32, ) -> Weight { - (73_918_000 as Weight) + (74_538_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_367_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_357_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64les(r: u32, ) -> Weight { - (73_953_000 as Weight) + (74_035_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_363_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_368_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64leu(r: u32, ) -> Weight { - (74_855_000 as Weight) - // Standard Error: 4_000 - .saturating_add((1_347_000 as Weight).saturating_mul(r as Weight)) + (74_399_000 as Weight) + // Standard Error: 8_000 + .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64ges(r: u32, ) -> Weight { - (73_917_000 as Weight) - // Standard Error: 2_000 + (73_987_000 as Weight) + // Standard Error: 1_000 .saturating_add((1_364_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64geu(r: u32, ) -> Weight { - (73_949_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_361_000 as Weight).saturating_mul(r as Weight)) + (74_017_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_366_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64add(r: u32, ) -> Weight { - (73_726_000 as Weight) - // Standard Error: 1_000 - .saturating_add((1_347_000 as Weight).saturating_mul(r as Weight)) + (74_271_000 as Weight) + // Standard Error: 2_000 + .saturating_add((1_330_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64sub(r: u32, ) -> Weight { - (73_921_000 as Weight) - // Standard Error: 1_000 + (74_016_000 as Weight) + // Standard Error: 0 .saturating_add((1_345_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64mul(r: u32, ) -> Weight { - (73_924_000 as Weight) + (74_063_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_341_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_338_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64divs(r: u32, ) -> Weight { - (73_842_000 as Weight) - // Standard Error: 2_000 - .saturating_add((2_011_000 as Weight).saturating_mul(r as Weight)) + (74_094_000 as Weight) + // Standard Error: 1_000 + .saturating_add((2_002_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64divu(r: u32, ) -> Weight { - (73_932_000 as Weight) - // Standard Error: 1_000 - .saturating_add((2_057_000 as Weight).saturating_mul(r as Weight)) + (73_957_000 as Weight) + // Standard Error: 2_000 + .saturating_add((2_045_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64rems(r: u32, ) -> Weight { - (74_028_000 as Weight) + (74_067_000 as Weight) // Standard Error: 2_000 - .saturating_add((2_001_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_975_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64remu(r: u32, ) -> Weight { - (73_784_000 as Weight) - // Standard Error: 2_000 - .saturating_add((2_059_000 as Weight).saturating_mul(r as Weight)) + (74_092_000 as Weight) + // Standard Error: 1_000 + .saturating_add((2_035_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64and(r: u32, ) -> Weight { - (74_169_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_334_000 as Weight).saturating_mul(r as Weight)) + (74_059_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_338_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64or(r: u32, ) -> Weight { - (73_982_000 as Weight) - // Standard Error: 2_000 - .saturating_add((1_340_000 as Weight).saturating_mul(r as Weight)) + (74_122_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_335_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64xor(r: u32, ) -> Weight { - (74_310_000 as Weight) + (74_296_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_329_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_333_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64shl(r: u32, ) -> Weight { - (73_861_000 as Weight) + (73_810_000 as Weight) // Standard Error: 2_000 - .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_368_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64shrs(r: u32, ) -> Weight { - (73_787_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_364_000 as Weight).saturating_mul(r as Weight)) + (74_101_000 as Weight) + // Standard Error: 9_000 + .saturating_add((1_407_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64shru(r: u32, ) -> Weight { - (73_886_000 as Weight) - // Standard Error: 7_000 - .saturating_add((1_372_000 as Weight).saturating_mul(r as Weight)) + (74_076_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_353_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64rotl(r: u32, ) -> Weight { - (73_860_000 as Weight) - // Standard Error: 3_000 - .saturating_add((1_362_000 as Weight).saturating_mul(r as Weight)) + (74_082_000 as Weight) + // Standard Error: 1_000 + .saturating_add((1_354_000 as Weight).saturating_mul(r as Weight)) } fn instr_i64rotr(r: u32, ) -> Weight { - (73_917_000 as Weight) + (74_054_000 as Weight) // Standard Error: 1_000 - .saturating_add((1_356_000 as Weight).saturating_mul(r as Weight)) + .saturating_add((1_355_000 as Weight).saturating_mul(r as Weight)) } }