diff --git a/substrate/frame/contracts/fixtures/caller_contract.wat b/substrate/frame/contracts/fixtures/caller_contract.wat
index 9c7cdf62abfc94f4918f1b4985ab2311c59420c6..f9caf49f29ca8ae6c3e8dcf8fe5781987003c458 100644
--- a/substrate/frame/contracts/fixtures/caller_contract.wat
+++ b/substrate/frame/contracts/fixtures/caller_contract.wat
@@ -16,27 +16,11 @@
)
)
- (func $current_balance (param $sp i32) (result i64)
- (i32.store
- (i32.sub (get_local $sp) (i32.const 16))
- (i32.const 8)
- )
- (call $seal_balance
- (i32.sub (get_local $sp) (i32.const 8))
- (i32.sub (get_local $sp) (i32.const 16))
- )
- (call $assert
- (i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 16))) (i32.const 8))
- )
- (i64.load (i32.sub (get_local $sp) (i32.const 8)))
- )
-
(func (export "deploy"))
(func (export "call")
(local $sp i32)
(local $exit_code i32)
- (local $balance i64)
;; Length of the buffer
(i32.store (i32.const 20) (i32.const 32))
@@ -54,9 +38,6 @@
;; Read current balance into local variable.
(set_local $sp (i32.const 1024))
- (set_local $balance
- (call $current_balance (get_local $sp))
- )
;; Fail to deploy the contract since it returns a non-zero exit status.
(set_local $exit_code
@@ -82,11 +63,6 @@
(i32.eq (get_local $exit_code) (i32.const 2)) ;; ReturnCode::CalleeReverted
)
- ;; Check that balance has not changed.
- (call $assert
- (i64.eq (get_local $balance) (call $current_balance (get_local $sp)))
- )
-
;; Fail to deploy the contract due to insufficient gas.
(set_local $exit_code
(call $seal_instantiate
@@ -112,11 +88,6 @@
(i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped
)
- ;; Check that balance has not changed.
- (call $assert
- (i64.eq (get_local $balance) (call $current_balance (get_local $sp)))
- )
-
;; Length of the output buffer
(i32.store
(i32.sub (get_local $sp) (i32.const 4))
@@ -153,14 +124,6 @@
(i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 4))) (i32.const 32))
)
- ;; Check that balance has been deducted.
- (set_local $balance
- (i64.sub (get_local $balance) (i64.load (i32.const 0)))
- )
- (call $assert
- (i64.eq (get_local $balance) (call $current_balance (get_local $sp)))
- )
-
;; Zero out destination buffer of output
(i32.store
(i32.sub (get_local $sp) (i32.const 4))
@@ -204,11 +167,6 @@
)
)
- ;; Check that balance has not changed.
- (call $assert
- (i64.eq (get_local $balance) (call $current_balance (get_local $sp)))
- )
-
;; Fail to call the contract due to insufficient gas.
(set_local $exit_code
(call $seal_call
@@ -229,11 +187,6 @@
(i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped
)
- ;; Check that balance has not changed.
- (call $assert
- (i64.eq (get_local $balance) (call $current_balance (get_local $sp)))
- )
-
;; Zero out destination buffer of output
(i32.store
(i32.sub (get_local $sp) (i32.const 4))
@@ -276,14 +229,6 @@
(i32.const 0x77665544)
)
)
-
- ;; Check that balance has been deducted.
- (set_local $balance
- (i64.sub (get_local $balance) (i64.load (i32.const 0)))
- )
- (call $assert
- (i64.eq (get_local $balance) (call $current_balance (get_local $sp)))
- )
)
(data (i32.const 0) "\00\80") ;; The value to transfer on instantiation and calls.
diff --git a/substrate/frame/contracts/fixtures/drain.wat b/substrate/frame/contracts/fixtures/drain.wat
index 94c65184226674e2b1554bf910527ffe8a13b9cc..9f126898fac81e48d62581d61fbbfc2c8a009bc1 100644
--- a/substrate/frame/contracts/fixtures/drain.wat
+++ b/substrate/frame/contracts/fixtures/drain.wat
@@ -34,8 +34,7 @@
)
;; Try to self-destruct by sending full balance to the 0 address.
- ;; All the *free* balance will be send away, which is a valid thing to do
- ;; because the storage deposits will keep the account alive.
+ ;; The call will fail because a contract transfer has a keep alive requirement
(call $assert
(i32.eq
(call $seal_transfer
@@ -44,7 +43,7 @@
(i32.const 0) ;; Pointer to the buffer with value to transfer
(i32.const 8) ;; Length of the buffer with value to transfer
)
- (i32.const 0) ;; ReturnCode::Success
+ (i32.const 5) ;; ReturnCode::TransferFailed
)
)
)
diff --git a/substrate/frame/contracts/primitives/src/lib.rs b/substrate/frame/contracts/primitives/src/lib.rs
index 1811ae09c0572e834b49fcd399d0831e4cb8153a..f5b8da249517ec3e71f88e76319ab10a6bcb7c91 100644
--- a/substrate/frame/contracts/primitives/src/lib.rs
+++ b/substrate/frame/contracts/primitives/src/lib.rs
@@ -47,10 +47,12 @@ pub struct ContractResult<R, Balance> {
/// Additionally, any `seal_call` or `seal_instantiate` makes use of pre-charging
/// when a non-zero `gas_limit` argument is supplied.
pub gas_required: Weight,
- /// How much balance was deposited and reserved during execution in order to pay for storage.
+ /// How much balance was paid by the origin into the contract's deposit account in order to
+ /// pay for storage.
///
- /// The storage deposit is never actually charged from the caller in case of [`Self::result`]
- /// is `Err`. This is because on error all storage changes are rolled back.
+ /// The storage deposit is never actually charged from the origin in case of [`Self::result`]
+ /// is `Err`. This is because on error all storage changes are rolled back including the
+ /// payment of the deposit.
pub storage_deposit: StorageDeposit<Balance>,
/// An optional debug message. This message is only filled when explicitly requested
/// by the code that calls into the contract. Otherwise it is empty.
@@ -159,12 +161,12 @@ pub enum StorageDeposit<Balance> {
/// The transaction reduced storage consumption.
///
/// This means that the specified amount of balance was transferred from the involved
- /// contracts to the call origin.
+ /// deposit accounts to the origin.
Refund(Balance),
- /// The transaction increased overall storage usage.
+ /// The transaction increased storage consumption.
///
- /// This means that the specified amount of balance was transferred from the call origin
- /// to the contracts involved.
+ /// This means that the specified amount of balance was transferred from the origin
+ /// to the involved deposit accounts.
Charge(Balance),
}
diff --git a/substrate/frame/contracts/src/address.rs b/substrate/frame/contracts/src/address.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b1bb1f48b91c2997a3a634562ae1b84fa7b4454
--- /dev/null
+++ b/substrate/frame/contracts/src/address.rs
@@ -0,0 +1,81 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Functions that deal with address derivation.
+
+use crate::{CodeHash, Config};
+use codec::{Decode, Encode};
+use sp_runtime::traits::{Hash, TrailingZeroInput};
+
+/// Provides the contract address generation method.
+///
+/// See [`DefaultAddressGenerator`] for the default implementation.
+///
+/// # Note for implementors
+///
+/// 1. Make sure that there are no collisions, different inputs never lead to the same output.
+/// 2. Make sure that the same inputs lead to the same output.
+pub trait AddressGenerator<T: Config> {
+ /// The address of a contract based on the given instantiate parameters.
+ ///
+ /// Changing the formular for an already deployed chain is fine as long as no collisons
+ /// with the old formular. Changes only affect existing contracts.
+ fn contract_address(
+ deploying_address: &T::AccountId,
+ code_hash: &CodeHash<T>,
+ input_data: &[u8],
+ salt: &[u8],
+ ) -> T::AccountId;
+
+ /// The address of the deposit account of `contract_addr`.
+ ///
+ /// The address is generated once on instantiation and then stored in the contracts
+ /// metadata. Hence changes do only affect newly created contracts.
+ fn deposit_address(contract_addr: &T::AccountId) -> T::AccountId;
+}
+
+/// Default address generator.
+///
+/// This is the default address generator used by contract instantiation. Its result
+/// is only dependent on its inputs. It can therefore be used to reliably predict the
+/// address of a contract. This is akin to the formula of eth's CREATE2 opcode. There
+/// is no CREATE equivalent because CREATE2 is strictly more powerful.
+/// Formula:
+/// `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)`
+pub struct DefaultAddressGenerator;
+
+impl<T: Config> AddressGenerator<T> for DefaultAddressGenerator {
+ /// Formula: `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)`
+ fn contract_address(
+ deploying_address: &T::AccountId,
+ code_hash: &CodeHash<T>,
+ input_data: &[u8],
+ salt: &[u8],
+ ) -> T::AccountId {
+ let entropy = (b"contract_addr_v1", deploying_address, code_hash, input_data, salt)
+ .using_encoded(T::Hashing::hash);
+ Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+ .expect("infinite length input; no invalid inputs for type; qed")
+ }
+
+ /// Formula: `hash("contract_depo_v1" ++ contract_addr)`
+ fn deposit_address(contract_addr: &T::AccountId) -> T::AccountId {
+ let entropy = (b"contract_depo_v1", contract_addr).using_encoded(T::Hashing::hash);
+ Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+ .expect("infinite length input; no invalid inputs for type; qed")
+ }
+}
diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs
index 55d315d5c7be1906b746723f9b38da04536edbb1..ed41cece1730143295005933edfb268a888c0223 100644
--- a/substrate/frame/contracts/src/benchmarking/mod.rs
+++ b/substrate/frame/contracts/src/benchmarking/mod.rs
@@ -32,7 +32,6 @@ use self::{
use crate::{
exec::{AccountIdOf, FixSizedKey, VarSizedKey},
schedule::{API_BENCHMARK_BATCH_SIZE, INSTR_BENCHMARK_BATCH_SIZE},
- storage::Storage,
wasm::CallFlags,
Pallet as Contracts, *,
};
@@ -133,14 +132,8 @@ where
fn store(&self, items: &Vec<(FixSizedKey, Vec<u8>)>) -> Result<(), &'static str> {
let info = self.info()?;
for item in items {
- Storage::<T>::write(
- &info.trie_id,
- &item.0 as &FixSizedKey,
- Some(item.1.clone()),
- None,
- false,
- )
- .map_err(|_| "Failed to write storage to restoration dest")?;
+ info.write(&item.0 as &FixSizedKey, Some(item.1.clone()), None, false)
+ .map_err(|_| "Failed to write storage to restoration dest")?;
}
<ContractInfoOf<T>>::insert(&self.account_id, info);
Ok(())
@@ -207,7 +200,7 @@ benchmarks! {
// The base weight consumed on processing contracts deletion queue.
#[pov_mode = Measured]
on_process_deletion_queue_batch {}: {
- Storage::<T>::process_deletion_queue_batch(Weight::MAX)
+ ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
}
#[skip_meta]
@@ -215,9 +208,9 @@ benchmarks! {
on_initialize_per_trie_key {
let k in 0..1024;
let instance = Contract::<T>::with_storage(WasmModule::dummy(), k, T::Schedule::get().limits.payload_len)?;
- Storage::<T>::queue_trie_for_deletion(&instance.info()?)?;
+ instance.info()?.queue_trie_for_deletion()?;
}: {
- Storage::<T>::process_deletion_queue_batch(Weight::MAX)
+ ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
}
#[pov_mode = Measured]
@@ -225,11 +218,11 @@ benchmarks! {
let q in 0..1024.min(T::DeletionQueueDepth::get());
for i in 0 .. q {
let instance = Contract::<T>::with_index(i, WasmModule::dummy(), vec![])?;
- Storage::<T>::queue_trie_for_deletion(&instance.info()?)?;
+ instance.info()?.queue_trie_for_deletion()?;
ContractInfoOf::<T>::remove(instance.account_id);
}
}: {
- Storage::<T>::process_deletion_queue_batch(Weight::MAX)
+ ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
}
// This benchmarks the additional weight that is charged when a contract is executed the
@@ -293,18 +286,16 @@ benchmarks! {
let addr = Contracts::<T>::contract_address(&caller, &hash, &input, &salt);
}: _(origin, value, Weight::MAX, None, code, input, salt)
verify {
- // the contract itself does not trigger any reserves
- let deposit = T::Currency::reserved_balance(&addr);
+ let deposit_account = Contract::<T>::address_info(&addr)?.deposit_account().clone();
+ let deposit = T::Currency::free_balance(&deposit_account);
// uploading the code reserves some balance in the callers account
let code_deposit = T::Currency::reserved_balance(&caller);
assert_eq!(
T::Currency::free_balance(&caller),
- caller_funding::<T>() - value - deposit - code_deposit,
+ caller_funding::<T>() - value - deposit - code_deposit - Pallet::<T>::min_balance(),
);
// contract has the full value
- assert_eq!(T::Currency::free_balance(&addr), value);
- // instantiate should leave a contract
- Contract::<T>::address_info(&addr)?;
+ assert_eq!(T::Currency::free_balance(&addr), value + Pallet::<T>::min_balance());
}
// Instantiate uses a dummy contract constructor to measure the overhead of the instantiate.
@@ -325,14 +316,15 @@ benchmarks! {
Contracts::<T>::store_code_raw(code, caller.clone())?;
}: _(origin, value, Weight::MAX, None, hash, input, salt)
verify {
- // the contract itself does not trigger any reserves
- let deposit = T::Currency::reserved_balance(&addr);
+ let deposit_account = Contract::<T>::address_info(&addr)?.deposit_account().clone();
+ let deposit = T::Currency::free_balance(&deposit_account);
// value was removed from the caller
- assert_eq!(T::Currency::free_balance(&caller), caller_funding::<T>() - value - deposit);
+ assert_eq!(
+ T::Currency::free_balance(&caller),
+ caller_funding::<T>() - value - deposit - Pallet::<T>::min_balance(),
+ );
// contract has the full value
- assert_eq!(T::Currency::free_balance(&addr), value);
- // instantiate should leave a contract
- Contract::<T>::address_info(&addr)?;
+ assert_eq!(T::Currency::free_balance(&addr), value + Pallet::<T>::min_balance());
}
// We just call a dummy contract to measure the overhead of the call extrinsic.
@@ -348,18 +340,19 @@ benchmarks! {
let instance = Contract::<T>::with_caller(
whitelisted_caller(), WasmModule::dummy(), vec![],
)?;
+ let deposit_account = instance.info()?.deposit_account().clone();
let value = Pallet::<T>::min_balance();
let origin = RawOrigin::Signed(instance.caller.clone());
let callee = instance.addr.clone();
let before = T::Currency::free_balance(&instance.account_id);
+ let before_deposit = T::Currency::free_balance(&deposit_account);
}: _(origin, callee, value, Weight::MAX, None, data)
verify {
- // the contract itself does not trigger any reserves
- let deposit = T::Currency::reserved_balance(&instance.account_id);
+ let deposit = T::Currency::free_balance(&deposit_account);
// value and value transfered via call should be removed from the caller
assert_eq!(
T::Currency::free_balance(&instance.caller),
- caller_funding::<T>() - instance.value - value - deposit,
+ caller_funding::<T>() - instance.value - value - deposit - Pallet::<T>::min_balance(),
);
// contract should have received the value
assert_eq!(T::Currency::free_balance(&instance.account_id), before + value);
@@ -798,14 +791,16 @@ benchmarks! {
});
let instance = Contract::<T>::new(code, vec![])?;
let origin = RawOrigin::Signed(instance.caller.clone());
+ let deposit_account = instance.info()?.deposit_account().clone();
assert_eq!(T::Currency::total_balance(&beneficiary), 0u32.into());
- assert_eq!(T::Currency::free_balance(&instance.account_id), Pallet::<T>::min_balance());
- assert_ne!(T::Currency::reserved_balance(&instance.account_id), 0u32.into());
+ assert_eq!(T::Currency::free_balance(&instance.account_id), Pallet::<T>::min_balance() * 2u32.into());
+ assert_ne!(T::Currency::free_balance(&deposit_account), 0u32.into());
}: call(origin, instance.addr.clone(), 0u32.into(), Weight::MAX, None, vec![])
verify {
if r > 0 {
assert_eq!(T::Currency::total_balance(&instance.account_id), 0u32.into());
- assert_eq!(T::Currency::total_balance(&beneficiary), Pallet::<T>::min_balance());
+ assert_eq!(T::Currency::total_balance(&deposit_account), 0u32.into());
+ assert_eq!(T::Currency::total_balance(&beneficiary), Pallet::<T>::min_balance() * 2u32.into());
}
}
@@ -1039,8 +1034,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
@@ -1088,8 +1082,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
@@ -1137,8 +1130,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
@@ -1188,8 +1180,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
@@ -1236,8 +1227,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
@@ -1291,8 +1281,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
@@ -1346,8 +1335,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
@@ -1396,8 +1384,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
@@ -1444,8 +1431,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
@@ -1499,8 +1485,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![]),
None,
@@ -1554,8 +1539,7 @@ benchmarks! {
let instance = Contract::<T>::new(code, vec![])?;
let info = instance.info()?;
for key in keys {
- Storage::<T>::write(
- &info.trie_id,
+ info.write(
&VarSizedKey::<T>::try_from(key).map_err(|e| "Key has wrong length")?,
Some(vec![42u8; (n * 2048) as usize]), // value_len increments by 2kb up to max payload_len
None,
@@ -1884,7 +1868,7 @@ benchmarks! {
.. Default::default()
});
let instance = Contract::<T>::new(code, vec![])?;
- instance.set_balance(value * (r * API_BENCHMARK_BATCH_SIZE + 1).into());
+ instance.set_balance((value + Pallet::<T>::min_balance()) * (r * API_BENCHMARK_BATCH_SIZE + 1).into());
let origin = RawOrigin::Signed(instance.caller.clone());
let callee = instance.addr.clone();
let addresses = hashes
@@ -1997,7 +1981,7 @@ benchmarks! {
.. Default::default()
});
let instance = Contract::<T>::new(code, vec![])?;
- instance.set_balance(value * (API_BENCHMARK_BATCH_SIZE + 1).into());
+ instance.set_balance((value + Pallet::<T>::min_balance()) * (API_BENCHMARK_BATCH_SIZE + 1).into());
let origin = RawOrigin::Signed(instance.caller.clone());
}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
@@ -3113,8 +3097,8 @@ benchmarks! {
{
let weight_limit = T::DeletionWeightLimit::get();
let max_queue_depth = T::DeletionQueueDepth::get() as usize;
- let empty_queue_throughput = Storage::<T>::deletion_budget(0, weight_limit);
- let full_queue_throughput = Storage::<T>::deletion_budget(max_queue_depth, weight_limit);
+ let empty_queue_throughput = ContractInfo::<T>::deletion_budget(0, weight_limit);
+ let full_queue_throughput = ContractInfo::<T>::deletion_budget(max_queue_depth, weight_limit);
println!("{:#?}", Schedule::<T>::default());
println!("###############################################");
println!("Lazy deletion weight per key: {}", empty_queue_throughput.0);
diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs
index 9b033a76cf0ff70cd1ee228d8d49f49eefc1cb75..92930cc79139703c82677b26069e73320aff0477 100644
--- a/substrate/frame/contracts/src/exec.rs
+++ b/substrate/frame/contracts/src/exec.rs
@@ -17,9 +17,9 @@
use crate::{
gas::GasMeter,
- storage::{self, Storage, WriteOutcome},
+ storage::{self, DepositAccount, WriteOutcome},
BalanceOf, CodeHash, Config, ContractInfo, ContractInfoOf, DebugBufferVec, Determinism, Error,
- Event, Nonce, Pallet as Contracts, Schedule,
+ Event, Nonce, Pallet as Contracts, Schedule, System,
};
use frame_support::{
crypto::ecdsa::ECDSAExt,
@@ -492,7 +492,7 @@ enum CachedContract<T: Config> {
///
/// In this case a reload is neither allowed nor possible. Please note that recursive
/// calls cannot remove a contract as this is checked and denied.
- Terminated,
+ Terminated(DepositAccount<T>),
}
impl<T: Config> CachedContract<T> {
@@ -513,6 +513,15 @@ impl<T: Config> CachedContract<T> {
None
}
}
+
+ /// Returns `Some` iff the contract is not `Cached::Invalidated`.
+ fn deposit_account(&self) -> Option<&DepositAccount<T>> {
+ match self {
+ CachedContract::Cached(contract) => Some(contract.deposit_account()),
+ CachedContract::Terminated(deposit_account) => Some(&deposit_account),
+ CachedContract::Invalidated => None,
+ }
+ }
}
impl<T: Config> Frame<T> {
@@ -591,7 +600,9 @@ impl<T: Config> CachedContract<T> {
/// Terminate and return the contract info.
fn terminate(&mut self, account_id: &T::AccountId) -> ContractInfo<T> {
self.load(account_id);
- get_cached_or_panic_after_load!(mem::replace(self, Self::Terminated))
+ let contract = get_cached_or_panic_after_load!(self);
+ let deposit_account = contract.deposit_account().clone();
+ get_cached_or_panic_after_load!(mem::replace(self, Self::Terminated(deposit_account)))
}
}
@@ -751,9 +762,7 @@ where
input_data,
salt,
);
- let trie_id = Storage::<T>::generate_trie_id(&account_id, nonce);
- let contract =
- Storage::<T>::new_contract(&account_id, trie_id, *executable.code_hash())?;
+ let contract = ContractInfo::new(&account_id, nonce, *executable.code_hash())?;
(
account_id,
contract,
@@ -873,7 +882,7 @@ where
match (entry_point, delegated_code_hash) {
(ExportedFunction::Constructor, _) => {
// It is not allowed to terminate a contract inside its constructor.
- if matches!(frame.contract_info, CachedContract::Terminated) {
+ if matches!(frame.contract_info, CachedContract::Terminated(_)) {
return Err(Error::<T>::TerminatedInConstructor.into())
}
@@ -962,11 +971,21 @@ where
// Record the storage meter changes of the nested call into the parent meter.
// If the dropped frame's contract wasn't terminated we update the deposit counter
- // in its contract info. The load is necessary to to pull it from storage in case
+ // in its contract info. The load is necessary to pull it from storage in case
// it was invalidated.
frame.contract_info.load(account_id);
+ let deposit_account = frame
+ .contract_info
+ .deposit_account()
+ .expect(
+ "Is only `None` when the info is invalidated.
+ We just re-loaded from storage which either makes the state `Cached` or `Terminated`.
+ qed",
+ )
+ .clone();
let mut contract = frame.contract_info.into_contract();
- prev.nested_storage.absorb(frame.nested_storage, account_id, contract.as_mut());
+ prev.nested_storage
+ .absorb(frame.nested_storage, deposit_account, contract.as_mut());
// In case the contract wasn't terminated we need to persist changes made to it.
if let Some(contract) = contract {
@@ -1001,10 +1020,14 @@ where
if !persist {
return
}
+ let deposit_account = self.first_frame.contract_info.deposit_account().expect(
+ "Is only `None` when the info is invalidated. The first frame can't be invalidated.
+ qed",
+ ).clone();
let mut contract = self.first_frame.contract_info.as_contract();
self.storage_meter.absorb(
mem::take(&mut self.first_frame.nested_storage),
- &self.first_frame.account_id,
+ deposit_account,
contract.as_deref_mut(),
);
if let Some(contract) = contract {
@@ -1182,19 +1205,21 @@ where
}
fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> Result<(), DispatchError> {
+ use frame_support::traits::fungible::Inspect;
if self.is_recursive() {
return Err(Error::<T>::TerminatedWhileReentrant.into())
}
let frame = self.top_frame_mut();
let info = frame.terminate();
frame.nested_storage.terminate(&info);
- Storage::<T>::queue_trie_for_deletion(&info)?;
- <Stack<'a, T, E>>::transfer(
- ExistenceRequirement::AllowDeath,
+ System::<T>::dec_consumers(&frame.account_id);
+ T::Currency::transfer(
&frame.account_id,
beneficiary,
- T::Currency::free_balance(&frame.account_id),
+ T::Currency::reducible_balance(&frame.account_id, false),
+ ExistenceRequirement::AllowDeath,
)?;
+ info.queue_trie_for_deletion()?;
ContractInfoOf::<T>::remove(&frame.account_id);
E::remove_user(info.code_hash);
Contracts::<T>::deposit_event(
@@ -1212,19 +1237,19 @@ where
}
fn get_storage(&mut self, key: &FixSizedKey) -> Option<Vec<u8>> {
- Storage::<T>::read(&self.top_frame_mut().contract_info().trie_id, key)
+ self.top_frame_mut().contract_info().read(key)
}
fn get_storage_transparent(&mut self, key: &VarSizedKey<T>) -> Option<Vec<u8>> {
- Storage::<T>::read(&self.top_frame_mut().contract_info().trie_id, key)
+ self.top_frame_mut().contract_info().read(key)
}
fn get_storage_size(&mut self, key: &FixSizedKey) -> Option<u32> {
- Storage::<T>::size(&self.top_frame_mut().contract_info().trie_id, key)
+ self.top_frame_mut().contract_info().size(key)
}
fn get_storage_size_transparent(&mut self, key: &VarSizedKey<T>) -> Option<u32> {
- Storage::<T>::size(&self.top_frame_mut().contract_info().trie_id, key)
+ self.top_frame_mut().contract_info().size(key)
}
fn set_storage(
@@ -1234,8 +1259,7 @@ where
take_old: bool,
) -> Result<WriteOutcome, DispatchError> {
let frame = self.top_frame_mut();
- Storage::<T>::write(
- &frame.contract_info.get(&frame.account_id).trie_id,
+ frame.contract_info.get(&frame.account_id).write(
key,
value,
Some(&mut frame.nested_storage),
@@ -1250,8 +1274,7 @@ where
take_old: bool,
) -> Result<WriteOutcome, DispatchError> {
let frame = self.top_frame_mut();
- Storage::<T>::write(
- &frame.contract_info.get(&frame.account_id).trie_id,
+ frame.contract_info.get(&frame.account_id).write(
key,
value,
Some(&mut frame.nested_storage),
@@ -1438,7 +1461,6 @@ mod tests {
use crate::{
exec::ExportedFunction::*,
gas::GasMeter,
- storage::Storage,
tests::{
test_utils::{get_balance, hash, place_contract, set_balance},
ExtBuilder, RuntimeCall, RuntimeEvent as MetaEvent, Test, TestFilter, ALICE, BOB,
@@ -1891,9 +1913,8 @@ mod tests {
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
let executable =
MockExecutable::from_storage(input_data_ch, &schedule, &mut gas_meter).unwrap();
- set_balance(&ALICE, min_balance * 1000);
- let mut storage_meter =
- storage::meter::Meter::new(&ALICE, Some(min_balance * 100), min_balance).unwrap();
+ set_balance(&ALICE, min_balance * 10_000);
+ let mut storage_meter = storage::meter::Meter::new(&ALICE, None, min_balance).unwrap();
let result = MockStack::run_instantiate(
ALICE,
@@ -2231,7 +2252,7 @@ mod tests {
// Check that the newly created account has the expected code hash and
// there are instantiation event.
assert_eq!(
- Storage::<Test>::code_hash(&instantiated_contract_address).unwrap(),
+ ContractInfo::<Test>::load_code_hash(&instantiated_contract_address).unwrap(),
dummy_ch
);
assert_eq!(
@@ -2273,7 +2294,7 @@ mod tests {
);
// Check that the account has not been created.
- assert!(Storage::<Test>::code_hash(&instantiated_contract_address).is_none());
+ assert!(ContractInfo::<Test>::load_code_hash(&instantiated_contract_address).is_none());
assert!(events().is_empty());
});
}
@@ -2332,7 +2353,7 @@ mod tests {
// Check that the newly created account has the expected code hash and
// there are instantiation event.
assert_eq!(
- Storage::<Test>::code_hash(&instantiated_contract_address).unwrap(),
+ ContractInfo::<Test>::load_code_hash(&instantiated_contract_address).unwrap(),
dummy_ch
);
assert_eq!(
@@ -2374,7 +2395,7 @@ mod tests {
set_balance(&ALICE, 1000);
set_balance(&BOB, 100);
place_contract(&BOB, instantiator_ch);
- let mut storage_meter = storage::meter::Meter::new(&ALICE, Some(100), 0).unwrap();
+ let mut storage_meter = storage::meter::Meter::new(&ALICE, Some(200), 0).unwrap();
assert_matches!(
MockStack::run_call(
@@ -2409,8 +2430,8 @@ mod tests {
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
let executable =
MockExecutable::from_storage(terminate_ch, &schedule, &mut gas_meter).unwrap();
- set_balance(&ALICE, 1000);
- let mut storage_meter = storage::meter::Meter::new(&ALICE, Some(100), 100).unwrap();
+ set_balance(&ALICE, 10_000);
+ let mut storage_meter = storage::meter::Meter::new(&ALICE, None, 100).unwrap();
assert_eq!(
MockStack::run_instantiate(
@@ -2494,9 +2515,8 @@ mod tests {
let min_balance = <Test as Config>::Currency::minimum_balance();
let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
let executable = MockExecutable::from_storage(code, &schedule, &mut gas_meter).unwrap();
- set_balance(&ALICE, min_balance * 1000);
- let mut storage_meter =
- storage::meter::Meter::new(&ALICE, Some(min_balance * 100), min_balance).unwrap();
+ set_balance(&ALICE, min_balance * 10_000);
+ let mut storage_meter = storage::meter::Meter::new(&ALICE, None, min_balance).unwrap();
let result = MockStack::run_instantiate(
ALICE,
@@ -2902,10 +2922,9 @@ mod tests {
MockExecutable::from_storage(succ_fail_code, &schedule, &mut gas_meter).unwrap();
let succ_succ_executable =
MockExecutable::from_storage(succ_succ_code, &schedule, &mut gas_meter).unwrap();
- set_balance(&ALICE, min_balance * 1000);
+ set_balance(&ALICE, min_balance * 10_000);
let mut storage_meter =
- storage::meter::Meter::new(&ALICE, Some(min_balance * 500), min_balance * 100)
- .unwrap();
+ storage::meter::Meter::new(&ALICE, None, min_balance * 100).unwrap();
MockStack::run_instantiate(
ALICE,
diff --git a/substrate/frame/contracts/src/lib.rs b/substrate/frame/contracts/src/lib.rs
index e131a2685bad9afbcfc68330afc9d534d5534f32..a5f35a9cb5f3baee989d54c642a67dd3e11c178b 100644
--- a/substrate/frame/contracts/src/lib.rs
+++ b/substrate/frame/contracts/src/lib.rs
@@ -85,6 +85,7 @@
#[macro_use]
mod gas;
+mod address;
mod benchmarking;
mod exec;
mod migration;
@@ -101,11 +102,11 @@ mod tests;
use crate::{
exec::{AccountIdOf, ExecError, Executable, Stack as ExecStack},
gas::GasMeter,
- storage::{meter::Meter as StorageMeter, ContractInfo, DeletedContract, Storage},
+ storage::{meter::Meter as StorageMeter, ContractInfo, DeletedContract},
wasm::{OwnerInfo, PrefabWasmModule, TryInstantiate},
weights::WeightInfo,
};
-use codec::{Codec, Decode, Encode, HasCompact};
+use codec::{Codec, Encode, HasCompact};
use frame_support::{
dispatch::{Dispatchable, GetDispatchInfo, Pays, PostDispatchInfo},
ensure,
@@ -124,10 +125,11 @@ use pallet_contracts_primitives::{
};
use scale_info::TypeInfo;
use smallvec::Array;
-use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup, TrailingZeroInput};
+use sp_runtime::traits::{Convert, Hash, Saturating, StaticLookup};
use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
pub use crate::{
+ address::{AddressGenerator, DefaultAddressGenerator},
exec::{Frame, VarSizedKey as StorageKey},
migration::Migration,
pallet::*,
@@ -155,49 +157,6 @@ type DebugBufferVec<T> = BoundedVec<u8, <T as Config>::MaxDebugBufferLen>;
/// that this value makes sense for a memory location or length.
const SENTINEL: u32 = u32::MAX;
-/// Provides the contract address generation method.
-///
-/// See [`DefaultAddressGenerator`] for the default implementation.
-pub trait AddressGenerator<T: Config> {
- /// Generate the address of a contract based on the given instantiate parameters.
- ///
- /// # Note for implementors
- /// 1. Make sure that there are no collisions, different inputs never lead to the same output.
- /// 2. Make sure that the same inputs lead to the same output.
- /// 3. Changing the implementation through a runtime upgrade without a proper storage migration
- /// would lead to catastrophic misbehavior.
- fn generate_address(
- deploying_address: &T::AccountId,
- code_hash: &CodeHash<T>,
- input_data: &[u8],
- salt: &[u8],
- ) -> T::AccountId;
-}
-
-/// Default address generator.
-///
-/// This is the default address generator used by contract instantiation. Its result
-/// is only dependant on its inputs. It can therefore be used to reliably predict the
-/// address of a contract. This is akin to the formula of eth's CREATE2 opcode. There
-/// is no CREATE equivalent because CREATE2 is strictly more powerful.
-/// Formula:
-/// `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)`
-pub struct DefaultAddressGenerator;
-
-impl<T: Config> AddressGenerator<T> for DefaultAddressGenerator {
- fn generate_address(
- deploying_address: &T::AccountId,
- code_hash: &CodeHash<T>,
- input_data: &[u8],
- salt: &[u8],
- ) -> T::AccountId {
- let entropy = (b"contract_addr_v1", deploying_address, code_hash, input_data, salt)
- .using_encoded(T::Hashing::hash);
- Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
- .expect("infinite length input; no invalid inputs for type; qed")
- }
-}
-
#[frame_support::pallet]
pub mod pallet {
use super::*;
@@ -365,7 +324,7 @@ pub mod pallet {
#[pallet::hooks]
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
fn on_idle(_block: T::BlockNumber, remaining_weight: Weight) -> Weight {
- Storage::<T>::process_deletion_queue_batch(remaining_weight)
+ ContractInfo::<T>::process_deletion_queue_batch(remaining_weight)
.saturating_add(T::WeightInfo::on_process_deletion_queue_batch())
}
@@ -381,7 +340,7 @@ pub mod pallet {
.max_block
.saturating_sub(System::<T>::block_weight().total())
.min(T::DeletionWeightLimit::get());
- Storage::<T>::process_deletion_queue_batch(weight_limit)
+ ContractInfo::<T>::process_deletion_queue_batch(weight_limit)
.saturating_add(T::WeightInfo::on_process_deletion_queue_batch())
} else {
T::WeightInfo::on_process_deletion_queue_batch()
@@ -1129,8 +1088,7 @@ impl<T: Config> Pallet<T> {
let contract_info =
ContractInfoOf::<T>::get(&address).ok_or(ContractAccessError::DoesntExist)?;
- let maybe_value = Storage::<T>::read(
- &contract_info.trie_id,
+ let maybe_value = contract_info.read(
&StorageKey::<T>::try_from(key).map_err(|_| ContractAccessError::KeyDecodingFailed)?,
);
Ok(maybe_value)
@@ -1146,12 +1104,12 @@ impl<T: Config> Pallet<T> {
input_data: &[u8],
salt: &[u8],
) -> T::AccountId {
- T::AddressGenerator::generate_address(deploying_address, code_hash, input_data, salt)
+ T::AddressGenerator::contract_address(deploying_address, code_hash, input_data, salt)
}
/// Returns the code hash of the contract specified by `account` ID.
pub fn code_hash(account: &AccountIdOf<T>) -> Option<CodeHash<T>> {
- Storage::<T>::code_hash(account)
+ ContractInfo::<T>::load_code_hash(account)
}
/// Store code for benchmarks which does not check nor instrument the code.
diff --git a/substrate/frame/contracts/src/storage.rs b/substrate/frame/contracts/src/storage.rs
index bf030a2bd8c81f9dfe2ded19b3dedde649690b26..35db33c4ca0b22d27b425c8f6dc7f7266d165f46 100644
--- a/substrate/frame/contracts/src/storage.rs
+++ b/substrate/frame/contracts/src/storage.rs
@@ -22,13 +22,15 @@ pub mod meter;
use crate::{
exec::{AccountIdOf, StorageKey},
weights::WeightInfo,
- BalanceOf, CodeHash, Config, ContractInfoOf, DeletionQueue, Error, TrieId, SENTINEL,
+ AddressGenerator, BalanceOf, CodeHash, Config, ContractInfoOf, DeletionQueue, Error, Pallet,
+ TrieId, SENTINEL,
};
use codec::{Decode, Encode, MaxEncodedLen};
use frame_support::{
dispatch::{DispatchError, DispatchResult},
storage::child::{self, ChildInfo},
weights::Weight,
+ RuntimeDebugNoBound,
};
use scale_info::TypeInfo;
use sp_io::KillStorageResult;
@@ -36,7 +38,7 @@ use sp_runtime::{
traits::{Hash, Saturating, Zero},
RuntimeDebug,
};
-use sp_std::{marker::PhantomData, prelude::*};
+use sp_std::{ops::Deref, prelude::*};
/// Information for managing an account and its sub trie abstraction.
/// This is the required info to cache for an account.
@@ -45,28 +47,68 @@ use sp_std::{marker::PhantomData, prelude::*};
pub struct ContractInfo<T: Config> {
/// Unique ID for the subtree encoded as a bytes vector.
pub trie_id: TrieId,
+ /// The account that holds this contracts storage deposit.
+ ///
+ /// This is held in a separate account to prevent the contract from spending it.
+ deposit_account: DepositAccount<T>,
/// The code associated with a given account.
pub code_hash: CodeHash<T>,
/// How many bytes of storage are accumulated in this contract's child trie.
- pub storage_bytes: u32,
+ storage_bytes: u32,
/// How many items of storage are accumulated in this contract's child trie.
- pub storage_items: u32,
+ storage_items: u32,
/// This records to how much deposit the accumulated `storage_bytes` amount to.
pub storage_byte_deposit: BalanceOf<T>,
/// This records to how much deposit the accumulated `storage_items` amount to.
- pub storage_item_deposit: BalanceOf<T>,
+ storage_item_deposit: BalanceOf<T>,
/// This records how much deposit is put down in order to pay for the contract itself.
///
/// We need to store this information separately so it is not used when calculating any refunds
/// since the base deposit can only ever be refunded on contract termination.
- pub storage_base_deposit: BalanceOf<T>,
+ storage_base_deposit: BalanceOf<T>,
}
impl<T: Config> ContractInfo<T> {
+ /// Constructs a new contract info **without** writing it to storage.
+ ///
+ /// This returns an `Err` if an contract with the supplied `account` already exists
+ /// in storage.
+ pub fn new(
+ account: &AccountIdOf<T>,
+ nonce: u64,
+ code_hash: CodeHash<T>,
+ ) -> Result<Self, DispatchError> {
+ if <ContractInfoOf<T>>::contains_key(account) {
+ return Err(Error::<T>::DuplicateContract.into())
+ }
+
+ let trie_id = {
+ let buf = (account, nonce).using_encoded(T::Hashing::hash);
+ buf.as_ref()
+ .to_vec()
+ .try_into()
+ .expect("Runtime uses a reasonable hash size. Hence sizeof(T::Hash) <= 128; qed")
+ };
+
+ let deposit_account = DepositAccount(T::AddressGenerator::deposit_address(account));
+
+ let contract = Self {
+ trie_id,
+ deposit_account,
+ code_hash,
+ storage_bytes: 0,
+ storage_items: 0,
+ storage_byte_deposit: Zero::zero(),
+ storage_item_deposit: Zero::zero(),
+ storage_base_deposit: Zero::zero(),
+ };
+
+ Ok(contract)
+ }
+
/// Associated child trie unique id is built from the hash part of the trie id.
- #[cfg(test)]
pub fn child_trie_info(&self) -> ChildInfo {
- child_trie_info(&self.trie_id[..])
+ ChildInfo::new_default(self.trie_id.as_ref())
}
/// The deposit paying for the accumulated storage generated within the contract's child trie.
@@ -76,79 +118,30 @@ impl<T: Config> ContractInfo<T> {
/// Same as [`Self::extra_deposit`] but including the base deposit.
pub fn total_deposit(&self) -> BalanceOf<T> {
- self.extra_deposit().saturating_add(self.storage_base_deposit)
+ self.extra_deposit()
+ .saturating_add(self.storage_base_deposit)
+ .saturating_sub(Pallet::<T>::min_balance())
}
-}
-
-/// Associated child trie unique id is built from the hash part of the trie id.
-fn child_trie_info(trie_id: &[u8]) -> ChildInfo {
- ChildInfo::new_default(trie_id)
-}
-
-#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]
-pub struct DeletedContract {
- pub(crate) trie_id: TrieId,
-}
-/// Information about what happended to the pre-existing value when calling [`Storage::write`].
-#[cfg_attr(test, derive(Debug, PartialEq))]
-pub enum WriteOutcome {
- /// No value existed at the specified key.
- New,
- /// A value of the returned length was overwritten.
- Overwritten(u32),
- /// The returned value was taken out of storage before being overwritten.
- ///
- /// This is only returned when specifically requested because it causes additional work
- /// depending on the size of the pre-existing value. When not requested [`Self::Overwritten`]
- /// is returned instead.
- Taken(Vec<u8>),
-}
-
-impl WriteOutcome {
- /// Extracts the size of the overwritten value or `0` if there
- /// was no value in storage.
- pub fn old_len(&self) -> u32 {
- match self {
- Self::New => 0,
- Self::Overwritten(len) => *len,
- Self::Taken(value) => value.len() as u32,
- }
+ /// Return the account that storage deposits should be deposited into.
+ pub fn deposit_account(&self) -> &DepositAccount<T> {
+ &self.deposit_account
}
- /// Extracts the size of the overwritten value or `SENTINEL` if there
- /// was no value in storage.
- ///
- /// # Note
- ///
- /// We cannot use `0` as sentinel value because there could be a zero sized
- /// storage entry which is different from a non existing one.
- pub fn old_len_with_sentinel(&self) -> u32 {
- match self {
- Self::New => SENTINEL,
- Self::Overwritten(len) => *len,
- Self::Taken(value) => value.len() as u32,
- }
- }
-}
-
-pub struct Storage<T>(PhantomData<T>);
-
-impl<T: Config> Storage<T> {
/// Reads a storage kv pair of a contract.
///
/// The read is performed from the `trie_id` only. The `address` is not necessary. If the
/// contract doesn't store under the given `key` `None` is returned.
- pub fn read<K: StorageKey<T>>(trie_id: &TrieId, key: &K) -> Option<Vec<u8>> {
- child::get_raw(&child_trie_info(trie_id), key.hash().as_slice())
+ pub fn read<K: StorageKey<T>>(&self, key: &K) -> Option<Vec<u8>> {
+ child::get_raw(&self.child_trie_info(), key.hash().as_slice())
}
/// Returns `Some(len)` (in bytes) if a storage item exists at `key`.
///
/// Returns `None` if the `key` wasn't previously set by `set_storage` or
/// was deleted.
- pub fn size<K: StorageKey<T>>(trie_id: &TrieId, key: &K) -> Option<u32> {
- child::len(&child_trie_info(trie_id), key.hash().as_slice())
+ pub fn size<K: StorageKey<T>>(&self, key: &K) -> Option<u32> {
+ child::len(&self.child_trie_info(), key.hash().as_slice())
}
/// Update a storage entry into a contract's kv storage.
@@ -159,13 +152,13 @@ impl<T: Config> Storage<T> {
/// This function also records how much storage was created or removed if a `storage_meter`
/// is supplied. It should only be absent for testing or benchmarking code.
pub fn write<K: StorageKey<T>>(
- trie_id: &TrieId,
+ &self,
key: &K,
new_value: Option<Vec<u8>>,
storage_meter: Option<&mut meter::NestedMeter<T>>,
take: bool,
) -> Result<WriteOutcome, DispatchError> {
- let child_trie_info = &child_trie_info(trie_id);
+ let child_trie_info = &self.child_trie_info();
let hashed_key = key.hash();
let (old_len, old_value) = if take {
let val = child::get_raw(child_trie_info, &hashed_key);
@@ -208,37 +201,11 @@ impl<T: Config> Storage<T> {
})
}
- /// Creates a new contract descriptor in the storage with the given code hash at the given
- /// address.
- ///
- /// Returns `Err` if there is already a contract at the given address.
- pub fn new_contract(
- account: &AccountIdOf<T>,
- trie_id: TrieId,
- code_hash: CodeHash<T>,
- ) -> Result<ContractInfo<T>, DispatchError> {
- if <ContractInfoOf<T>>::contains_key(account) {
- return Err(Error::<T>::DuplicateContract.into())
- }
-
- let contract = ContractInfo::<T> {
- code_hash,
- trie_id,
- storage_bytes: 0,
- storage_items: 0,
- storage_byte_deposit: Zero::zero(),
- storage_item_deposit: Zero::zero(),
- storage_base_deposit: Zero::zero(),
- };
-
- Ok(contract)
- }
-
/// Push a contract's trie to the deletion queue for lazy removal.
///
/// You must make sure that the contract is also removed when queuing the trie for deletion.
- pub fn queue_trie_for_deletion(contract: &ContractInfo<T>) -> DispatchResult {
- <DeletionQueue<T>>::try_append(DeletedContract { trie_id: contract.trie_id.clone() })
+ pub fn queue_trie_for_deletion(&self) -> DispatchResult {
+ <DeletionQueue<T>>::try_append(DeletedContract { trie_id: self.trie_id.clone() })
.map_err(|_| <Error<T>>::DeletionQueueFull.into())
}
@@ -289,7 +256,10 @@ impl<T: Config> Storage<T> {
// Cannot panic due to loop condition
let trie = &mut queue[0];
#[allow(deprecated)]
- let outcome = child::kill_storage(&child_trie_info(&trie.trie_id), Some(remaining_key_budget));
+ let outcome = child::kill_storage(
+ &ChildInfo::new_default(&trie.trie_id),
+ Some(remaining_key_budget),
+ );
let keys_removed = match outcome {
// This happens when our budget wasn't large enough to remove all keys.
KillStorageResult::SomeRemaining(c) => c,
@@ -307,17 +277,8 @@ impl<T: Config> Storage<T> {
weight_limit.saturating_sub(weight_per_key.saturating_mul(u64::from(remaining_key_budget)))
}
- /// Generates a unique trie id by returning `hash(account_id ++ nonce)`.
- pub fn generate_trie_id(account_id: &AccountIdOf<T>, nonce: u64) -> TrieId {
- let buf = (account_id, nonce).using_encoded(T::Hashing::hash);
- buf.as_ref()
- .to_vec()
- .try_into()
- .expect("Runtime uses a reasonable hash size. Hence sizeof(T::Hash) <= 128; qed")
- }
-
/// Returns the code hash of the contract specified by `account` ID.
- pub fn code_hash(account: &AccountIdOf<T>) -> Option<CodeHash<T>> {
+ pub fn load_code_hash(account: &AccountIdOf<T>) -> Option<CodeHash<T>> {
<ContractInfoOf<T>>::get(account).map(|i| i.code_hash)
}
@@ -332,3 +293,62 @@ impl<T: Config> Storage<T> {
<DeletionQueue<T>>::put(bounded);
}
}
+
+#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub struct DeletedContract {
+ pub(crate) trie_id: TrieId,
+}
+
+/// Information about what happended to the pre-existing value when calling [`ContractInfo::write`].
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub enum WriteOutcome {
+ /// No value existed at the specified key.
+ New,
+ /// A value of the returned length was overwritten.
+ Overwritten(u32),
+ /// The returned value was taken out of storage before being overwritten.
+ ///
+ /// This is only returned when specifically requested because it causes additional work
+ /// depending on the size of the pre-existing value. When not requested [`Self::Overwritten`]
+ /// is returned instead.
+ Taken(Vec<u8>),
+}
+
+impl WriteOutcome {
+ /// Extracts the size of the overwritten value or `0` if there
+ /// was no value in storage.
+ pub fn old_len(&self) -> u32 {
+ match self {
+ Self::New => 0,
+ Self::Overwritten(len) => *len,
+ Self::Taken(value) => value.len() as u32,
+ }
+ }
+
+ /// Extracts the size of the overwritten value or `SENTINEL` if there
+ /// was no value in storage.
+ ///
+ /// # Note
+ ///
+ /// We cannot use `0` as sentinel value because there could be a zero sized
+ /// storage entry which is different from a non existing one.
+ pub fn old_len_with_sentinel(&self) -> u32 {
+ match self {
+ Self::New => SENTINEL,
+ Self::Overwritten(len) => *len,
+ Self::Taken(value) => value.len() as u32,
+ }
+ }
+}
+
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+pub struct DepositAccount<T: Config>(AccountIdOf<T>);
+
+impl<T: Config> Deref for DepositAccount<T> {
+ type Target = AccountIdOf<T>;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
diff --git a/substrate/frame/contracts/src/storage/meter.rs b/substrate/frame/contracts/src/storage/meter.rs
index 94bca741af66191e47eac563bc8910165a34ae8d..5102edb78a09fae467e0538f2445fcb2fe6b2e06 100644
--- a/substrate/frame/contracts/src/storage/meter.rs
+++ b/substrate/frame/contracts/src/storage/meter.rs
@@ -17,22 +17,19 @@
//! This module contains functions to meter the storage deposit.
-use crate::{storage::ContractInfo, BalanceOf, Config, Error, Inspect, Pallet};
+use crate::{
+ storage::{ContractInfo, DepositAccount},
+ BalanceOf, Config, Error, Inspect, Pallet, System,
+};
use codec::Encode;
use frame_support::{
dispatch::DispatchError,
ensure,
- traits::{
- tokens::{BalanceStatus, WithdrawConsequence},
- Currency, ExistenceRequirement, Get, ReservableCurrency,
- },
+ traits::{tokens::WithdrawConsequence, Currency, ExistenceRequirement, Get},
DefaultNoBound, RuntimeDebugNoBound,
};
use pallet_contracts_primitives::StorageDeposit as Deposit;
-use sp_runtime::{
- traits::{Saturating, Zero},
- FixedPointNumber, FixedU128,
-};
+use sp_runtime::{traits::Saturating, FixedPointNumber, FixedU128};
use sp_std::{marker::PhantomData, vec::Vec};
/// Deposit that uses the native currency's balance type.
@@ -72,14 +69,14 @@ pub trait Ext<T: Config> {
/// This is called to inform the implementer that some balance should be charged due to
/// some interaction of the `origin` with a `contract`.
///
- /// The balance transfer can either flow from `origin` to `contract` or the other way
+ /// The balance transfer can either flow from `origin` to `deposit_account` or the other way
/// around depending on whether `amount` constitutes a `Charge` or a `Refund`.
- /// It is guaranteed that that this succeeds because no more balance than returned by
+ /// It is guaranteed that this succeeds because no more balance than returned by
/// `check_limit` is ever charged. This is why this function is infallible.
/// `terminated` designates whether the `contract` was terminated.
fn charge(
origin: &T::AccountId,
- contract: &T::AccountId,
+ deposit_account: &DepositAccount<T>,
amount: &DepositOf<T>,
terminated: bool,
);
@@ -216,7 +213,7 @@ impl Diff {
/// essentially makes the order of storage changes irrelevant with regard to the deposit system.
#[derive(RuntimeDebugNoBound, Clone)]
struct Charge<T: Config> {
- contract: T::AccountId,
+ deposit_account: DepositAccount<T>,
amount: DepositOf<T>,
terminated: bool,
}
@@ -270,8 +267,8 @@ where
/// Absorb a child that was spawned to handle a sub call.
///
/// This should be called whenever a sub call comes to its end and it is **not** reverted.
- /// This does the actual balance transfer from/to `origin` and `contract` based on the overall
- /// storage consumption of the call. It also updates the supplied contract info.
+ /// This does the actual balance transfer from/to `origin` and `deposit_account` based on the
+ /// overall storage consumption of the call. It also updates the supplied contract info.
///
/// In case a contract reverted the child meter should just be dropped in order to revert
/// any changes it recorded.
@@ -280,12 +277,12 @@ where
///
/// - `absorbed`: The child storage meter that should be absorbed.
/// - `origin`: The origin that spawned the original root meter.
- /// - `contract`: The contract that this sub call belongs to.
+ /// - `deposit_account`: The contract's deposit account that this sub call belongs to.
/// - `info`: The info of the contract in question. `None` if the contract was terminated.
pub fn absorb(
&mut self,
absorbed: RawMeter<T, E, Nested>,
- contract: &T::AccountId,
+ deposit_account: DepositAccount<T>,
info: Option<&mut ContractInfo<T>>,
) {
let own_deposit = absorbed.own_contribution.update_contract(info);
@@ -296,7 +293,7 @@ where
if !own_deposit.is_zero() {
self.charges.extend_from_slice(&absorbed.charges);
self.charges.push(Charge {
- contract: contract.clone(),
+ deposit_account,
amount: own_deposit,
terminated: absorbed.is_terminated(),
});
@@ -345,10 +342,10 @@ where
/// execution did finish.
pub fn into_deposit(self, origin: &T::AccountId) -> DepositOf<T> {
for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Refund(_))) {
- E::charge(origin, &charge.contract, &charge.amount, charge.terminated);
+ E::charge(origin, &charge.deposit_account, &charge.amount, charge.terminated);
}
for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Charge(_))) {
- E::charge(origin, &charge.contract, &charge.amount, charge.terminated);
+ E::charge(origin, &charge.deposit_account, &charge.amount, charge.terminated);
}
self.total_deposit
}
@@ -360,9 +357,8 @@ where
T: Config,
E: Ext<T>,
{
- /// Try to charge the `diff` from the meter. Fails if this would exceed the original limit.
+ /// Charge `diff` from the meter.
pub fn charge(&mut self, diff: &Diff) {
- debug_assert!(self.is_alive());
match &mut self.own_contribution {
Contribution::Alive(own) => *own = own.saturating_add(diff),
_ => panic!("Charge is never called after termination; qed"),
@@ -379,13 +375,16 @@ where
info: &mut ContractInfo<T>,
) -> Result<DepositOf<T>, DispatchError> {
debug_assert!(self.is_alive());
+
+ let ed = Pallet::<T>::min_balance();
let mut deposit =
Diff { bytes_added: info.encoded_size() as u32, items_added: 1, ..Default::default() }
.update_contract::<T>(None);
- // Instantiate needs to transfer the minimum balance at least in order to pull the
- // contract's account into existence.
- deposit = deposit.max(Deposit::Charge(Pallet::<T>::min_balance()));
+ // Instantiate needs to transfer at least the minimum balance in order to pull the
+ // deposit account into existence.
+ // We also add another `ed` here which goes to the contract's own account into existence.
+ deposit = deposit.max(Deposit::Charge(ed)).saturating_add(&Deposit::Charge(ed));
if deposit.charge_or_zero() > self.limit {
return Err(<Error<T>>::StorageDepositLimitExhausted.into())
}
@@ -394,11 +393,22 @@ where
// contract execution does conclude and hence would lead to a double charge.
self.total_deposit = deposit.clone();
info.storage_base_deposit = deposit.charge_or_zero();
- if !deposit.is_zero() {
- // We need to charge immediately so that the account is created before the `value`
- // is transferred from the caller to the contract.
- E::charge(origin, contract, &deposit, false);
- }
+
+ // Usually, deposit charges are deferred to be able to coalesce them with refunds.
+ // However, we need to charge immediately so that the account is created before
+ // charges possibly below the ed are collected and fail.
+ E::charge(
+ origin,
+ info.deposit_account(),
+ &deposit.saturating_sub(&Deposit::Charge(ed)),
+ false,
+ );
+ System::<T>::inc_consumers(info.deposit_account())?;
+
+ // We also need to make sure that the contract's account itself exists.
+ T::Currency::transfer(origin, contract, ed, ExistenceRequirement::KeepAlive)?;
+ System::<T>::inc_consumers(contract)?;
+
Ok(deposit)
}
@@ -443,7 +453,12 @@ impl<T: Config> Ext<T> for ReservingExt {
limit: Option<BalanceOf<T>>,
min_leftover: BalanceOf<T>,
) -> Result<BalanceOf<T>, DispatchError> {
- let max = T::Currency::reducible_balance(origin, true).saturating_sub(min_leftover);
+ // We are sending the `min_leftover` and the `min_balance` from the origin
+ // account as part of a contract call. Hence origin needs to have those left over
+ // as free balance after accounting for all deposits.
+ let max = T::Currency::reducible_balance(origin, true)
+ .saturating_sub(min_leftover)
+ .saturating_sub(Pallet::<T>::min_balance());
let limit = limit.unwrap_or(max);
ensure!(
limit <= max &&
@@ -455,67 +470,67 @@ impl<T: Config> Ext<T> for ReservingExt {
fn charge(
origin: &T::AccountId,
- contract: &T::AccountId,
+ deposit_account: &DepositAccount<T>,
amount: &DepositOf<T>,
terminated: bool,
) {
- // There is nothing we can do when this fails as this constitutes a bug in the runtime:
- // Either the runtime does not hold up the invariant of never deleting a contract's account
- // or it does not honor reserved balances. We need to settle for emitting an error log
- // in this case.
+ // There is nothing we can do when this fails as this constitutes a bug in the runtime.
+ // We need to settle for emitting an error log in this case.
+ //
+ // # Note
+ //
+ // This is infallible because it is called in a part of the execution where we cannot
+ // simply roll back. It might make sense to do some refactoring to move the deposit
+ // collection to the fallible part of execution.
match amount {
Deposit::Charge(amount) => {
- // This will never fail because a contract's account is required to exist
- // at all times. The pallet enforces this invariant by depositing at least the
- // existential deposit when instantiating and never refunds it unless the contract
- // is removed. This means the receiver always exists except when instantiating a
- // contract. In this case we made sure that at least the existential deposit is
- // sent. The sender always has enough balance because we checked that it had enough
- // balance when instantiating the storage meter.
+ // This will never fail because a deposit account is required to exist
+ // at all times. The pallet enforces this invariant by holding a consumer reference
+ // on the deposit account as long as the contract exists.
+ //
+ // The sender always has enough balance because we checked that it had enough
+ // balance when instantiating the storage meter. There is no way for the sender
+ // which is a plain account to send away this balance in the meantime.
let result = T::Currency::transfer(
origin,
- contract,
+ deposit_account,
*amount,
ExistenceRequirement::KeepAlive,
- )
- .and_then(|_| T::Currency::reserve(contract, *amount));
+ );
if let Err(err) = result {
log::error!(
target: "runtime::contracts",
- "Failed to transfer storage deposit {:?} from origin {:?} to contract {:?}: {:?}",
- amount, origin, contract, err,
+ "Failed to transfer storage deposit {:?} from origin {:?} to deposit account {:?}: {:?}",
+ amount, origin, deposit_account, err,
);
if cfg!(debug_assertions) {
panic!("Unable to collect storage deposit. This is a bug.");
}
}
},
- // For `Refund(_)` no error happen because the initial value transfer from the
- // origin to the contract has a keep alive existence requirement and when reserving we
- // make sure to leave at least the ed in the free balance. Therefore the receiver always
- // exists because there is no way for it to be removed in between. The sender always has
- // enough reserved balance because we track it in the `ContractInfo` and never send more
- // back than we have.
+ // The receiver always exists because the initial value transfer from the
+ // origin to the contract has a keep alive existence requirement. When taking a deposit
+ // we make sure to leave at least the ed in the free balance.
+ //
+ // The sender always has enough balance because we track it in the `ContractInfo` and
+ // never send more back than we have. Noone has access to the deposit account. Hence no
+ // other interaction with this account takes place.
Deposit::Refund(amount) => {
- let amount = if terminated {
- *amount
- } else {
- // This is necessary when the `storage_deposit` tracked inside the account
- // info is out of sync with the actual balance. That can only happen due to
- // slashing. We make sure to never dust the contract's account through a
- // refund because we consider this unexpected behaviour.
- *amount.min(
- &T::Currency::reserved_balance(contract)
- .saturating_sub(Pallet::<T>::min_balance()),
- )
- };
- let result =
- T::Currency::repatriate_reserved(contract, origin, amount, BalanceStatus::Free);
- if matches!(result, Ok(val) if !val.is_zero()) || matches!(result, Err(_)) {
+ if terminated {
+ System::<T>::dec_consumers(&deposit_account);
+ }
+ let result = T::Currency::transfer(
+ deposit_account,
+ origin,
+ *amount,
+ // We can safely use `AllowDeath` because our own consumer prevents an removal.
+ ExistenceRequirement::AllowDeath,
+ );
+ if matches!(result, Err(_)) {
log::error!(
target: "runtime::contracts",
- "Failed to repatriate storage deposit {:?} from contract {:?} to origin {:?}: {:?}",
- amount, contract, origin, result,
+ "Failed to refund storage deposit {:?} from deposit account {:?} to origin {:?}: {:?}",
+ amount, deposit_account, origin, result,
);
if cfg!(debug_assertions) {
panic!("Unable to refund storage deposit. This is a bug.");
@@ -558,7 +573,7 @@ mod tests {
#[derive(Debug, PartialEq, Eq, Clone)]
struct Charge {
origin: AccountIdOf<Test>,
- contract: AccountIdOf<Test>,
+ contract: DepositAccount<Test>,
amount: DepositOf<Test>,
terminated: bool,
}
@@ -592,7 +607,7 @@ mod tests {
fn charge(
origin: &AccountIdOf<Test>,
- contract: &AccountIdOf<Test>,
+ contract: &DepositAccount<Test>,
amount: &DepositOf<Test>,
terminated: bool,
) {
@@ -620,12 +635,10 @@ mod tests {
}
fn new_info(info: StorageInfo) -> ContractInfo<Test> {
- use crate::storage::Storage;
- use sp_runtime::traits::Hash;
-
ContractInfo::<Test> {
- trie_id: <Storage<Test>>::generate_trie_id(&ALICE, 42),
- code_hash: <Test as frame_system::Config>::Hashing::hash(b"42"),
+ trie_id: Default::default(),
+ deposit_account: DepositAccount([0u8; 32].into()),
+ code_hash: Default::default(),
storage_bytes: info.bytes,
storage_items: info.items,
storage_byte_deposit: info.bytes_deposit,
@@ -659,7 +672,7 @@ mod tests {
// an empty charge does not create a `Charge` entry
let mut nested0 = meter.nested();
nested0.charge(&Default::default());
- meter.absorb(nested0, &BOB, None);
+ meter.absorb(nested0, DepositAccount(BOB), None);
assert_eq!(
TestExtTestValue::get(),
@@ -692,16 +705,16 @@ mod tests {
new_info(StorageInfo { bytes: 100, items: 10, bytes_deposit: 100, items_deposit: 20 });
let mut nested1 = nested0.nested();
nested1.charge(&Diff { items_removed: 5, ..Default::default() });
- nested0.absorb(nested1, &CHARLIE, Some(&mut nested1_info));
+ nested0.absorb(nested1, DepositAccount(CHARLIE), Some(&mut nested1_info));
let mut nested2_info =
new_info(StorageInfo { bytes: 100, items: 7, bytes_deposit: 100, items_deposit: 20 });
let mut nested2 = nested0.nested();
nested2.charge(&Diff { items_removed: 7, ..Default::default() });
- nested0.absorb(nested2, &CHARLIE, Some(&mut nested2_info));
+ nested0.absorb(nested2, DepositAccount(CHARLIE), Some(&mut nested2_info));
nested0.enforce_limit(Some(&mut nested0_info)).unwrap();
- meter.absorb(nested0, &BOB, Some(&mut nested0_info));
+ meter.absorb(nested0, DepositAccount(BOB), Some(&mut nested0_info));
meter.into_deposit(&ALICE);
@@ -716,19 +729,19 @@ mod tests {
charges: vec![
Charge {
origin: ALICE,
- contract: CHARLIE,
+ contract: DepositAccount(CHARLIE),
amount: Deposit::Refund(10),
terminated: false
},
Charge {
origin: ALICE,
- contract: CHARLIE,
+ contract: DepositAccount(CHARLIE),
amount: Deposit::Refund(20),
terminated: false
},
Charge {
origin: ALICE,
- contract: BOB,
+ contract: DepositAccount(BOB),
amount: Deposit::Charge(2),
terminated: false
}
@@ -760,9 +773,9 @@ mod tests {
nested1.charge(&Diff { bytes_added: 20, ..Default::default() });
nested1.terminate(&nested1_info);
nested0.enforce_limit(Some(&mut nested1_info)).unwrap();
- nested0.absorb(nested1, &CHARLIE, None);
+ nested0.absorb(nested1, DepositAccount(CHARLIE), None);
- meter.absorb(nested0, &BOB, None);
+ meter.absorb(nested0, DepositAccount(BOB), None);
meter.into_deposit(&ALICE);
assert_eq!(
@@ -772,13 +785,13 @@ mod tests {
charges: vec![
Charge {
origin: ALICE,
- contract: CHARLIE,
- amount: Deposit::Refund(120),
+ contract: DepositAccount(CHARLIE),
+ amount: Deposit::Refund(119),
terminated: true
},
Charge {
origin: ALICE,
- contract: BOB,
+ contract: DepositAccount(BOB),
amount: Deposit::Charge(12),
terminated: false
}
diff --git a/substrate/frame/contracts/src/tests.rs b/substrate/frame/contracts/src/tests.rs
index cab426ad132cb1d360ca4aa211162ebe2626aaae..879268a68dca99ee8ab8d69b67bf2271060e846b 100644
--- a/substrate/frame/contracts/src/tests.rs
+++ b/substrate/frame/contracts/src/tests.rs
@@ -22,12 +22,11 @@ use crate::{
Result as ExtensionResult, RetVal, ReturnFlags, SysConfig,
},
exec::{FixSizedKey, Frame},
- storage::Storage,
tests::test_utils::{get_contract, get_contract_checked},
wasm::{Determinism, PrefabWasmModule, ReturnCode as RuntimeReturnCode},
weights::WeightInfo,
- BalanceOf, Code, CodeStorage, Config, ContractInfoOf, DefaultAddressGenerator, DeletionQueue,
- Error, Pallet, Schedule,
+ BalanceOf, Code, CodeStorage, Config, ContractInfo, ContractInfoOf, DefaultAddressGenerator,
+ DeletionQueue, Error, Pallet, Schedule,
};
use assert_matches::assert_matches;
use codec::Encode;
@@ -37,8 +36,8 @@ use frame_support::{
parameter_types,
storage::child,
traits::{
- BalanceStatus, ConstU32, ConstU64, Contains, Currency, Get, LockableCurrency, OnIdle,
- OnInitialize, ReservableCurrency, WithdrawReasons,
+ ConstU32, ConstU64, Contains, Currency, ExistenceRequirement, Get, LockableCurrency,
+ OnIdle, OnInitialize, ReservableCurrency, WithdrawReasons,
},
weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight},
};
@@ -51,7 +50,7 @@ use sp_runtime::{
traits::{BlakeTwo256, Convert, Hash, IdentityLookup},
AccountId32,
};
-use std::sync::Arc;
+use std::{ops::Deref, sync::Arc};
use crate as pallet_contracts;
@@ -76,9 +75,7 @@ frame_support::construct_runtime!(
#[macro_use]
pub mod test_utils {
use super::{Balances, Hash, SysConfig, Test};
- use crate::{
- exec::AccountIdOf, storage::Storage, CodeHash, Config, ContractInfo, ContractInfoOf, Nonce,
- };
+ use crate::{exec::AccountIdOf, CodeHash, Config, ContractInfo, ContractInfoOf, Nonce};
use codec::Encode;
use frame_support::traits::Currency;
@@ -87,9 +84,8 @@ pub mod test_utils {
*counter += 1;
*counter
});
- let trie_id = Storage::<Test>::generate_trie_id(address, nonce);
set_balance(address, <Test as Config>::Currency::minimum_balance() * 10);
- let contract = Storage::<Test>::new_contract(&address, trie_id, code_hash).unwrap();
+ let contract = <ContractInfo<Test>>::new(&address, nonce, code_hash).unwrap();
<ContractInfoOf<Test>>::insert(address, contract);
}
pub fn set_balance(who: &AccountIdOf<Test>, amount: u64) {
@@ -518,7 +514,7 @@ fn calling_plain_account_fails() {
fn instantiate_and_call_and_deposit_event() {
let (wasm, code_hash) = compile_module::<Test>("event_and_return_on_deploy").unwrap();
- ExtBuilder::default().existential_deposit(500).build().execute_with(|| {
+ ExtBuilder::default().existential_deposit(1).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
let min_balance = <Test as Config>::Currency::minimum_balance();
let value = 100;
@@ -551,21 +547,24 @@ fn instantiate_and_call_and_deposit_event() {
.account_id;
assert!(ContractInfoOf::<Test>::contains_key(&addr));
+ let contract = get_contract(&addr);
+ let deposit_account = contract.deposit_account().deref();
+
assert_eq!(
System::events(),
vec![
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::System(frame_system::Event::NewAccount {
- account: addr.clone()
+ account: deposit_account.clone(),
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
- account: addr.clone(),
- free_balance: min_balance,
+ account: deposit_account.clone(),
+ free_balance: 131,
}),
topics: vec![],
},
@@ -573,15 +572,31 @@ fn instantiate_and_call_and_deposit_event() {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: ALICE,
- to: addr.clone(),
- amount: min_balance,
+ to: deposit_account.clone(),
+ amount: 131,
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Reserved {
- who: addr.clone(),
+ event: RuntimeEvent::System(frame_system::Event::NewAccount {
+ account: addr.clone()
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+ account: addr.clone(),
+ free_balance: min_balance,
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+ from: ALICE,
+ to: addr.clone(),
amount: min_balance,
}),
topics: vec![],
@@ -823,7 +838,7 @@ fn deploy_and_call_other_contract() {
let (caller_wasm, _caller_code_hash) = compile_module::<Test>("caller_contract").unwrap();
let (callee_wasm, callee_code_hash) = compile_module::<Test>("return_with_data").unwrap();
- ExtBuilder::default().existential_deposit(500).build().execute_with(|| {
+ ExtBuilder::default().existential_deposit(1).build().execute_with(|| {
let min_balance = <Test as Config>::Currency::minimum_balance();
// Create
@@ -841,18 +856,7 @@ fn deploy_and_call_other_contract() {
.result
.unwrap()
.account_id;
- Contracts::bare_instantiate(
- ALICE,
- 100_000,
- GAS_LIMIT,
- None,
- Code::Upload(callee_wasm),
- 0u32.to_le_bytes().encode(),
- vec![42],
- false,
- )
- .result
- .unwrap();
+ Contracts::bare_upload_code(ALICE, callee_wasm, None, Determinism::Deterministic).unwrap();
let callee_addr = Contracts::contract_address(
&caller_addr,
@@ -875,21 +879,24 @@ fn deploy_and_call_other_contract() {
callee_code_hash.as_ref().to_vec(),
));
+ let callee = get_contract(&callee_addr);
+ let deposit_account = callee.deposit_account().deref();
+
assert_eq!(
System::events(),
vec![
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::System(frame_system::Event::NewAccount {
- account: callee_addr.clone()
+ account: deposit_account.clone(),
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
- account: callee_addr.clone(),
- free_balance: min_balance,
+ account: deposit_account.clone(),
+ free_balance: 131,
}),
topics: vec![],
},
@@ -897,15 +904,31 @@ fn deploy_and_call_other_contract() {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: ALICE,
- to: callee_addr.clone(),
- amount: min_balance,
+ to: deposit_account.clone(),
+ amount: 131,
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Reserved {
- who: callee_addr.clone(),
+ event: RuntimeEvent::System(frame_system::Event::NewAccount {
+ account: callee_addr.clone()
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+ account: callee_addr.clone(),
+ free_balance: min_balance,
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+ from: ALICE,
+ to: callee_addr.clone(),
amount: min_balance,
}),
topics: vec![],
@@ -915,7 +938,7 @@ fn deploy_and_call_other_contract() {
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: caller_addr.clone(),
to: callee_addr.clone(),
- amount: 32768, // hard coded in wasm
+ amount: 32768 // hardcoded in wasm
}),
topics: vec![],
},
@@ -999,8 +1022,8 @@ fn delegate_call() {
}
#[test]
-fn cannot_self_destruct_through_draning() {
- let (wasm, _code_hash) = compile_module::<Test>("drain").unwrap();
+fn transfer_allow_death_cannot_kill_account() {
+ let (wasm, _code_hash) = compile_module::<Test>("dummy").unwrap();
ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
@@ -1022,36 +1045,32 @@ fn cannot_self_destruct_through_draning() {
// Check that the BOB contract has been instantiated.
get_contract(&addr);
- // Call BOB which makes it send all funds to the zero address
- // The contract code asserts that the transfer was successful
- assert_ok!(Contracts::call(
- RuntimeOrigin::signed(ALICE),
- addr.clone(),
- 0,
- GAS_LIMIT,
- None,
- vec![]
- ));
+ let total_balance = <Test as Config>::Currency::total_balance(&addr);
- // Make sure the account wasn't remove by sending all free balance away.
- assert_eq!(
- <Test as Config>::Currency::total_balance(&addr),
- <Test as Config>::Currency::minimum_balance(),
+ assert_err!(
+ <<Test as Config>::Currency as Currency<AccountId32>>::transfer(
+ &addr,
+ &ALICE,
+ total_balance,
+ ExistenceRequirement::AllowDeath,
+ ),
+ pallet_balances::Error::<Test>::KeepAlive,
);
+
+ assert_eq!(<Test as Config>::Currency::total_balance(&addr), total_balance);
});
}
#[test]
-fn cannot_self_destruct_through_storage_refund_after_price_change() {
- let (wasm, _code_hash) = compile_module::<Test>("store").unwrap();
+fn cannot_self_destruct_through_draning() {
+ let (wasm, _code_hash) = compile_module::<Test>("drain").unwrap();
ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
- let min_balance = <Test as Config>::Currency::minimum_balance();
// Instantiate the BOB contract.
let addr = Contracts::bare_instantiate(
ALICE,
- 0,
+ 1_000,
GAS_LIMIT,
None,
Code::Upload(wasm),
@@ -1063,50 +1082,36 @@ fn cannot_self_destruct_through_storage_refund_after_price_change() {
.unwrap()
.account_id;
- // Check that the BOB contract has been instantiated and has the minimum balance
- assert_eq!(get_contract(&addr).total_deposit(), min_balance);
- assert_eq!(get_contract(&addr).extra_deposit(), 0);
- assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance);
-
- // Create 100 bytes of storage with a price of per byte and a single storage item of price 2
- assert_ok!(Contracts::call(
- RuntimeOrigin::signed(ALICE),
- addr.clone(),
- 0,
- GAS_LIMIT,
- None,
- 100u32.to_le_bytes().to_vec()
- ));
- assert_eq!(get_contract(&addr).total_deposit(), min_balance + 102);
+ // Check that the BOB contract has been instantiated.
+ get_contract(&addr);
- // Increase the byte price and trigger a refund. This should not have any influence because
- // the removal is pro rata and exactly those 100 bytes should have been removed.
- DEPOSIT_PER_BYTE.with(|c| *c.borrow_mut() = 500);
+ // Call BOB which makes it send all funds to the zero address
+ // The contract code asserts that the transfer fails with the correct error code
assert_ok!(Contracts::call(
RuntimeOrigin::signed(ALICE),
addr.clone(),
0,
GAS_LIMIT,
None,
- 0u32.to_le_bytes().to_vec()
+ vec![]
));
- // Make sure the account wasn't removed by the refund
+ // Make sure the account wasn't remove by sending all free balance away.
assert_eq!(
<Test as Config>::Currency::total_balance(&addr),
- get_contract(&addr).total_deposit(),
+ 1_000 + <Test as Config>::Currency::minimum_balance(),
);
- assert_eq!(get_contract(&addr).extra_deposit(), 2,);
});
}
#[test]
-fn cannot_self_destruct_by_refund_after_slash() {
+fn cannot_self_destruct_through_storage_refund_after_price_change() {
let (wasm, _code_hash) = compile_module::<Test>("store").unwrap();
- ExtBuilder::default().existential_deposit(500).build().execute_with(|| {
+ ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
let min_balance = <Test as Config>::Currency::minimum_balance();
+ // Instantiate the BOB contract.
let addr = Contracts::bare_instantiate(
ALICE,
0,
@@ -1121,68 +1126,40 @@ fn cannot_self_destruct_by_refund_after_slash() {
.unwrap()
.account_id;
- // create 100 more reserved balance
+ // Check that the BOB contract has been instantiated and has the minimum balance
+ assert_eq!(get_contract(&addr).total_deposit(), min_balance);
+ assert_eq!(get_contract(&addr).extra_deposit(), 0);
+ assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance);
+
+ // Create 100 bytes of storage with a price of per byte and a single storage item of price 2
assert_ok!(Contracts::call(
RuntimeOrigin::signed(ALICE),
addr.clone(),
0,
GAS_LIMIT,
None,
- 98u32.encode(),
+ 100u32.to_le_bytes().to_vec()
));
+ assert_eq!(get_contract(&addr).total_deposit(), min_balance + 102);
- // Drop previous events
- initialize_block(2);
-
- // slash parts of the 100 so that the next refund ould remove the account
- // because it the value it stored for `storage_deposit` becomes out of sync
- let _ = <Test as Config>::Currency::slash(&addr, 90);
- assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance + 10);
-
- // trigger a refund of 50 which would bring the contract below min when actually refunded
+ // Increase the byte price and trigger a refund. This should not have any influence because
+ // the removal is pro rata and exactly those 100 bytes should have been removed.
+ DEPOSIT_PER_BYTE.with(|c| *c.borrow_mut() = 500);
assert_ok!(Contracts::call(
RuntimeOrigin::signed(ALICE),
addr.clone(),
0,
GAS_LIMIT,
None,
- 48u32.encode(),
+ 0u32.to_le_bytes().to_vec()
));
- // Make sure the account kept the minimum balance and was not destroyed
- assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance);
-
+ // Make sure the account wasn't removed by the refund
assert_eq!(
- System::events(),
- vec![
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Slashed {
- who: addr.clone(),
- amount: 90,
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Contracts(crate::Event::Called {
- caller: ALICE,
- contract: addr.clone(),
- }),
- topics: vec![hash(&ALICE), hash(&addr)],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::ReserveRepatriated {
- from: addr.clone(),
- to: ALICE,
- amount: 10,
- destination_status: BalanceStatus::Free,
- }),
- topics: vec![],
- },
- ]
+ <Test as Config>::Currency::total_balance(get_contract(&addr).deposit_account()),
+ get_contract(&addr).total_deposit(),
);
+ assert_eq!(get_contract(&addr).extra_deposit(), 2);
});
}
@@ -1252,7 +1229,7 @@ fn self_destruct_works() {
.account_id;
// Check that the BOB contract has been instantiated.
- get_contract(&addr);
+ let contract = get_contract(&addr);
// Drop all previous events
initialize_block(2);
@@ -1271,17 +1248,25 @@ fn self_destruct_works() {
assert_eq!(Balances::total_balance(&addr), 0);
// check that the beneficiary (django) got remaining balance
- assert_eq!(Balances::free_balance(DJANGO), 1_000_000 + 100_000);
+ let ed = <Test as Config>::Currency::minimum_balance();
+ assert_eq!(Balances::free_balance(DJANGO), 1_000_000 + 100_000 + ed);
pretty_assertions::assert_eq!(
System::events(),
vec![
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::System(frame_system::Event::KilledAccount {
+ account: addr.clone()
+ }),
+ topics: vec![],
+ },
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: addr.clone(),
to: DJANGO,
- amount: 100_000,
+ amount: 100_000 + ed,
}),
topics: vec![],
},
@@ -1304,17 +1289,16 @@ fn self_destruct_works() {
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::System(frame_system::Event::KilledAccount {
- account: addr.clone()
+ account: contract.deposit_account().deref().clone(),
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::ReserveRepatriated {
- from: addr.clone(),
+ event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+ from: contract.deposit_account().deref().clone(),
to: ALICE,
amount: 1_000,
- destination_status: BalanceStatus::Free,
}),
topics: vec![],
},
@@ -2055,7 +2039,7 @@ fn lazy_removal_on_full_queue_works_on_initialize() {
ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
// Fill the deletion queue with dummy values, so that on_initialize attempts
// to clear the queue
- Storage::<Test>::fill_queue_with_dummies();
+ ContractInfo::<Test>::fill_queue_with_dummies();
let queue_len_initial = <DeletionQueue<Test>>::decode_len().unwrap_or(0);
@@ -2132,7 +2116,7 @@ fn lazy_removal_partial_remove_works() {
// We create a contract with some extra keys above the weight limit
let extra_keys = 7u32;
let weight_limit = Weight::from_ref_time(5_000_000_000);
- let (_, max_keys) = Storage::<Test>::deletion_budget(1, weight_limit);
+ let (_, max_keys) = ContractInfo::<Test>::deletion_budget(1, weight_limit);
let vals: Vec<_> = (0..max_keys + extra_keys)
.map(|i| (blake2_256(&i.encode()), (i as u32), (i as u32).encode()))
.collect();
@@ -2161,14 +2145,7 @@ fn lazy_removal_partial_remove_works() {
// Put value into the contracts child trie
for val in &vals {
- Storage::<Test>::write(
- &info.trie_id,
- &val.0 as &FixSizedKey,
- Some(val.2.clone()),
- None,
- false,
- )
- .unwrap();
+ info.write(&val.0 as &FixSizedKey, Some(val.2.clone()), None, false).unwrap();
}
<ContractInfoOf<Test>>::insert(&addr, info.clone());
@@ -2201,7 +2178,7 @@ fn lazy_removal_partial_remove_works() {
ext.execute_with(|| {
// Run the lazy removal
- let weight_used = Storage::<Test>::process_deletion_queue_batch(weight_limit);
+ let weight_used = ContractInfo::<Test>::process_deletion_queue_batch(weight_limit);
// Weight should be exhausted because we could not even delete all keys
assert_eq!(weight_used, weight_limit);
@@ -2235,7 +2212,7 @@ fn lazy_removal_does_no_run_on_full_queue_and_full_block() {
// Fill the deletion queue with dummy values, so that on_initialize attempts
// to clear the queue
- Storage::<Test>::fill_queue_with_dummies();
+ ContractInfo::<Test>::fill_queue_with_dummies();
// Check that on_initialize() tries to perform lazy removal but removes nothing
// as no more weight is left for that.
@@ -2344,7 +2321,7 @@ fn lazy_removal_does_not_use_all_weight() {
.account_id;
let info = get_contract(&addr);
- let (weight_per_key, max_keys) = Storage::<Test>::deletion_budget(1, weight_limit);
+ let (weight_per_key, max_keys) = ContractInfo::<Test>::deletion_budget(1, weight_limit);
// We create a contract with one less storage item than we can remove within the limit
let vals: Vec<_> = (0..max_keys - 1)
@@ -2353,14 +2330,7 @@ fn lazy_removal_does_not_use_all_weight() {
// Put value into the contracts child trie
for val in &vals {
- Storage::<Test>::write(
- &info.trie_id,
- &val.0 as &FixSizedKey,
- Some(val.2.clone()),
- None,
- false,
- )
- .unwrap();
+ info.write(&val.0 as &FixSizedKey, Some(val.2.clone()), None, false).unwrap();
}
<ContractInfoOf<Test>>::insert(&addr, info.clone());
@@ -2393,7 +2363,7 @@ fn lazy_removal_does_not_use_all_weight() {
ext.execute_with(|| {
// Run the lazy removal
- let weight_used = Storage::<Test>::process_deletion_queue_batch(weight_limit);
+ let weight_used = ContractInfo::<Test>::process_deletion_queue_batch(weight_limit);
// We have one less key in our trie than our weight limit suffices for
assert_eq!(weight_used, weight_limit - weight_per_key);
@@ -2427,7 +2397,7 @@ fn deletion_queue_full() {
.account_id;
// fill the deletion queue up until its limit
- Storage::<Test>::fill_queue_with_dummies();
+ ContractInfo::<Test>::fill_queue_with_dummies();
// Terminate the contract should fail
assert_err_ignore_postinfo!(
@@ -3196,14 +3166,12 @@ fn instantiate_with_zero_balance_works() {
.account_id;
// Check that the BOB contract has been instantiated.
- get_contract(&addr);
+ let contract = get_contract(&addr);
+ let deposit_account = contract.deposit_account().deref();
// Make sure the account exists even though no free balance was send
- assert_eq!(<Test as Config>::Currency::free_balance(&addr), 0,);
- assert_eq!(
- <Test as Config>::Currency::total_balance(&addr),
- <Test as Config>::Currency::minimum_balance(),
- );
+ assert_eq!(<Test as Config>::Currency::free_balance(&addr), min_balance);
+ assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance,);
assert_eq!(
System::events(),
@@ -3211,14 +3179,14 @@ fn instantiate_with_zero_balance_works() {
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::System(frame_system::Event::NewAccount {
- account: addr.clone()
+ account: deposit_account.clone(),
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
- account: addr.clone(),
+ account: deposit_account.clone(),
free_balance: min_balance,
}),
topics: vec![],
@@ -3227,15 +3195,31 @@ fn instantiate_with_zero_balance_works() {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: ALICE,
- to: addr.clone(),
+ to: deposit_account.clone(),
amount: min_balance,
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Reserved {
- who: addr.clone(),
+ event: RuntimeEvent::System(frame_system::Event::NewAccount {
+ account: addr.clone(),
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+ account: addr.clone(),
+ free_balance: min_balance,
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+ from: ALICE,
+ to: addr.clone(),
amount: min_balance,
}),
topics: vec![],
@@ -3292,14 +3276,12 @@ fn instantiate_with_below_existential_deposit_works() {
.account_id;
// Check that the BOB contract has been instantiated.
- get_contract(&addr);
+ let contract = get_contract(&addr);
+ let deposit_account = contract.deposit_account().deref();
- // Make sure the account exists even though no free balance was send
- assert_eq!(<Test as Config>::Currency::free_balance(&addr), 50,);
- assert_eq!(
- <Test as Config>::Currency::total_balance(&addr),
- <Test as Config>::Currency::minimum_balance() + 50,
- );
+ // Make sure the account exists even though not enough free balance was send
+ assert_eq!(<Test as Config>::Currency::free_balance(&addr), min_balance + 50);
+ assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance + 50);
assert_eq!(
System::events(),
@@ -3307,14 +3289,14 @@ fn instantiate_with_below_existential_deposit_works() {
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::System(frame_system::Event::NewAccount {
- account: addr.clone()
+ account: deposit_account.clone(),
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
- account: addr.clone(),
+ account: deposit_account.clone(),
free_balance: min_balance,
}),
topics: vec![],
@@ -3323,15 +3305,31 @@ fn instantiate_with_below_existential_deposit_works() {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: ALICE,
- to: addr.clone(),
+ to: deposit_account.clone(),
amount: min_balance,
}),
topics: vec![],
},
EventRecord {
phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Reserved {
- who: addr.clone(),
+ event: RuntimeEvent::System(frame_system::Event::NewAccount {
+ account: addr.clone()
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+ account: addr.clone(),
+ free_balance: min_balance,
+ }),
+ topics: vec![],
+ },
+ EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+ from: ALICE,
+ to: addr.clone(),
amount: min_balance,
}),
topics: vec![],
@@ -3436,6 +3434,9 @@ fn storage_deposit_works() {
deposit -= refunded0;
assert_eq!(get_contract(&addr).total_deposit(), deposit);
+ let contract = get_contract(&addr);
+ let deposit_account = contract.deposit_account().deref();
+
assert_eq!(
System::events(),
vec![
@@ -3460,15 +3461,7 @@ fn storage_deposit_works() {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: ALICE,
- to: addr.clone(),
- amount: charged0,
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Reserved {
- who: addr.clone(),
+ to: deposit_account.clone(),
amount: charged0,
}),
topics: vec![],
@@ -3485,15 +3478,7 @@ fn storage_deposit_works() {
phase: Phase::Initialization,
event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
from: ALICE,
- to: addr.clone(),
- amount: charged1,
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Reserved {
- who: addr.clone(),
+ to: deposit_account.clone(),
amount: charged1,
}),
topics: vec![],
@@ -3508,11 +3493,10 @@ fn storage_deposit_works() {
},
EventRecord {
phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::ReserveRepatriated {
- from: addr.clone(),
+ event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+ from: deposit_account.clone(),
to: ALICE,
amount: refunded0,
- destination_status: BalanceStatus::Free,
}),
topics: vec![],
},
@@ -3610,11 +3594,10 @@ fn set_code_extrinsic() {
}
#[test]
-fn call_after_killed_account_needs_funding() {
+fn slash_cannot_kill_account() {
let (wasm, _code_hash) = compile_module::<Test>("dummy").unwrap();
ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
let _ = Balances::deposit_creating(&ALICE, 1_000_000);
- let min_balance = <Test as Config>::Currency::minimum_balance();
let addr = Contracts::bare_instantiate(
ALICE,
@@ -3633,107 +3616,24 @@ fn call_after_killed_account_needs_funding() {
// Drop previous events
initialize_block(2);
- // Destroy the account of the contract by slashing.
- // Slashing can actually happen if the contract takes part in staking.
- // It is a corner case and we accept the destruction of the account.
+ // Try to destroy the account of the contract by slashing.
+ // The account does not get destroyed because of the consumer reference.
+ // Slashing can for example happen if the contract takes part in staking.
let _ = <Test as Config>::Currency::slash(
&addr,
<Test as Config>::Currency::total_balance(&addr),
);
- // Sending below the minimum balance will fail the call because it needs to create the
- // account in order to send balance there.
- assert_err_ignore_postinfo!(
- Contracts::call(
- RuntimeOrigin::signed(ALICE),
- addr.clone(),
- min_balance - 1,
- GAS_LIMIT,
- None,
- vec![],
- ),
- <Error<Test>>::TransferFailed
- );
-
- // Sending zero should work as it does not do a transfer
- assert_ok!(Contracts::call(
- RuntimeOrigin::signed(ALICE),
- addr.clone(),
- 0,
- GAS_LIMIT,
- None,
- vec![],
- ));
-
- // Sending minimum balance should work
- assert_ok!(Contracts::call(
- RuntimeOrigin::signed(ALICE),
- addr.clone(),
- min_balance,
- GAS_LIMIT,
- None,
- vec![],
- ));
-
assert_eq!(
System::events(),
- vec![
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::System(frame_system::Event::KilledAccount {
- account: addr.clone()
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Slashed {
- who: addr.clone(),
- amount: min_balance + 700
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Contracts(crate::Event::Called {
- caller: ALICE,
- contract: addr.clone(),
- }),
- topics: vec![hash(&ALICE), hash(&addr)],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::System(frame_system::Event::NewAccount {
- account: addr.clone()
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
- account: addr.clone(),
- free_balance: min_balance
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
- from: ALICE,
- to: addr.clone(),
- amount: min_balance
- }),
- topics: vec![],
- },
- EventRecord {
- phase: Phase::Initialization,
- event: RuntimeEvent::Contracts(crate::Event::Called {
- caller: ALICE,
- contract: addr.clone(),
- }),
- topics: vec![hash(&ALICE), hash(&addr)],
- },
- ]
+ vec![EventRecord {
+ phase: Phase::Initialization,
+ event: RuntimeEvent::Balances(pallet_balances::Event::Slashed {
+ who: addr.clone(),
+ amount: 700, // slash didn't remove the minimum balance
+ }),
+ topics: vec![],
+ },]
);
});
}
diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs
index 057a9257d42680e9dbf7cba4da017e22d3f0a50e..d032615843656f14b670f388cbf85c91fbe4790d 100644
--- a/substrate/frame/contracts/src/weights.rs
+++ b/substrate/frame/contracts/src/weights.rs
@@ -18,7 +18,7 @@
//! Autogenerated weights for pallet_contracts
//!
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-02-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-02-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
//! WORST CASE MAP SIZE: `1000000`
//! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
@@ -178,8 +178,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `109`
// Estimated: `604`
- // Minimum execution time: 2_507 nanoseconds.
- Weight::from_ref_time(2_650_000)
+ // Minimum execution time: 2_591 nanoseconds.
+ Weight::from_ref_time(2_817_000)
.saturating_add(Weight::from_proof_size(604))
.saturating_add(T::DbWeight::get().reads(1_u64))
}
@@ -190,11 +190,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `481 + k * (69 ±0)`
// Estimated: `471 + k * (70 ±0)`
- // Minimum execution time: 9_953 nanoseconds.
- Weight::from_ref_time(6_467_352)
+ // Minimum execution time: 10_190 nanoseconds.
+ Weight::from_ref_time(6_642_117)
.saturating_add(Weight::from_proof_size(471))
- // Standard Error: 1_074
- .saturating_add(Weight::from_ref_time(943_946).saturating_mul(k.into()))
+ // Standard Error: 992
+ .saturating_add(Weight::from_ref_time(919_828).saturating_mul(k.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
@@ -207,11 +207,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `281 + q * (33 ±0)`
// Estimated: `763 + q * (33 ±0)`
- // Minimum execution time: 2_545 nanoseconds.
- Weight::from_ref_time(10_080_106)
+ // Minimum execution time: 2_598 nanoseconds.
+ Weight::from_ref_time(10_288_252)
.saturating_add(Weight::from_proof_size(763))
- // Standard Error: 2_929
- .saturating_add(Weight::from_ref_time(1_078_265).saturating_mul(q.into()))
+ // Standard Error: 2_886
+ .saturating_add(Weight::from_ref_time(1_092_420).saturating_mul(q.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
.saturating_add(Weight::from_proof_size(33).saturating_mul(q.into()))
@@ -225,17 +225,17 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `270 + c * (1 ±0)`
// Estimated: `3025 + c * (2 ±0)`
- // Minimum execution time: 34_613 nanoseconds.
- Weight::from_ref_time(27_355_774)
+ // Minimum execution time: 34_338 nanoseconds.
+ Weight::from_ref_time(32_159_677)
.saturating_add(Weight::from_proof_size(3025))
- // Standard Error: 81
- .saturating_add(Weight::from_ref_time(51_954).saturating_mul(c.into()))
+ // Standard Error: 53
+ .saturating_add(Weight::from_ref_time(51_034).saturating_mul(c.into()))
.saturating_add(T::DbWeight::get().reads(1_u64))
.saturating_add(T::DbWeight::get().writes(1_u64))
.saturating_add(Weight::from_proof_size(2).saturating_mul(c.into()))
}
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -247,13 +247,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `c` is `[0, 125952]`.
fn call_with_code_per_byte(c: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `771`
- // Estimated: `16780 + c * (5 ±0)`
- // Minimum execution time: 386_104 nanoseconds.
- Weight::from_ref_time(396_718_823)
- .saturating_add(Weight::from_proof_size(16780))
+ // Measured: `803`
+ // Estimated: `16930 + c * (5 ±0)`
+ // Minimum execution time: 385_587 nanoseconds.
+ Weight::from_ref_time(395_545_811)
+ .saturating_add(Weight::from_proof_size(16930))
// Standard Error: 27
- .saturating_add(Weight::from_ref_time(31_370).saturating_mul(c.into()))
+ .saturating_add(Weight::from_ref_time(31_342).saturating_mul(c.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
.saturating_add(Weight::from_proof_size(5).saturating_mul(c.into()))
@@ -263,10 +263,10 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: Contracts Nonce (r:1 w:1)
/// Proof: Contracts Nonce (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
/// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
- /// Storage: System Account (r:1 w:1)
+ /// Storage: System Account (r:2 w:2)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: System EventTopics (r:3 w:3)
/// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured)
@@ -279,29 +279,29 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `s` is `[0, 1048576]`.
fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `257`
- // Estimated: `17752`
- // Minimum execution time: 3_786_500 nanoseconds.
- Weight::from_ref_time(672_511_565)
- .saturating_add(Weight::from_proof_size(17752))
- // Standard Error: 281
- .saturating_add(Weight::from_ref_time(94_538).saturating_mul(c.into()))
+ // Measured: `270`
+ // Estimated: `20267`
+ // Minimum execution time: 3_799_742 nanoseconds.
+ Weight::from_ref_time(670_115_588)
+ .saturating_add(Weight::from_proof_size(20267))
+ // Standard Error: 287
+ .saturating_add(Weight::from_ref_time(93_885).saturating_mul(c.into()))
// Standard Error: 16
- .saturating_add(Weight::from_ref_time(1_364).saturating_mul(i.into()))
+ .saturating_add(Weight::from_ref_time(1_367).saturating_mul(i.into()))
// Standard Error: 16
- .saturating_add(Weight::from_ref_time(1_768).saturating_mul(s.into()))
- .saturating_add(T::DbWeight::get().reads(8_u64))
- .saturating_add(T::DbWeight::get().writes(9_u64))
+ .saturating_add(Weight::from_ref_time(1_781).saturating_mul(s.into()))
+ .saturating_add(T::DbWeight::get().reads(9_u64))
+ .saturating_add(T::DbWeight::get().writes(10_u64))
}
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Contracts Nonce (r:1 w:1)
/// Proof: Contracts Nonce (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
/// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
- /// Storage: System Account (r:1 w:1)
+ /// Storage: System Account (r:2 w:2)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts OwnerInfoOf (r:1 w:1)
/// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured)
@@ -311,20 +311,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `s` is `[0, 1048576]`.
fn instantiate(i: u32, s: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `533`
- // Estimated: `19543`
- // Minimum execution time: 1_927_365 nanoseconds.
- Weight::from_ref_time(189_843_928)
- .saturating_add(Weight::from_proof_size(19543))
+ // Measured: `546`
+ // Estimated: `22039`
+ // Minimum execution time: 1_949_008 nanoseconds.
+ Weight::from_ref_time(214_033_418)
+ .saturating_add(Weight::from_proof_size(22039))
// Standard Error: 8
- .saturating_add(Weight::from_ref_time(1_677).saturating_mul(i.into()))
+ .saturating_add(Weight::from_ref_time(1_666).saturating_mul(i.into()))
// Standard Error: 8
- .saturating_add(Weight::from_ref_time(1_803).saturating_mul(s.into()))
- .saturating_add(T::DbWeight::get().reads(8_u64))
- .saturating_add(T::DbWeight::get().writes(6_u64))
+ .saturating_add(Weight::from_ref_time(1_801).saturating_mul(s.into()))
+ .saturating_add(T::DbWeight::get().reads(9_u64))
+ .saturating_add(T::DbWeight::get().writes(7_u64))
}
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -335,11 +335,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured)
fn call() -> Weight {
// Proof Size summary in bytes:
- // Measured: `823`
- // Estimated: `16985`
- // Minimum execution time: 146_354 nanoseconds.
- Weight::from_ref_time(147_693_000)
- .saturating_add(Weight::from_proof_size(16985))
+ // Measured: `855`
+ // Estimated: `17145`
+ // Minimum execution time: 146_654 nanoseconds.
+ Weight::from_ref_time(147_528_000)
+ .saturating_add(Weight::from_proof_size(17145))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
@@ -356,11 +356,11 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `109`
// Estimated: `5386`
- // Minimum execution time: 388_107 nanoseconds.
- Weight::from_ref_time(383_172_702)
+ // Minimum execution time: 387_889 nanoseconds.
+ Weight::from_ref_time(391_379_335)
.saturating_add(Weight::from_proof_size(5386))
- // Standard Error: 73
- .saturating_add(Weight::from_ref_time(95_037).saturating_mul(c.into()))
+ // Standard Error: 89
+ .saturating_add(Weight::from_ref_time(94_810).saturating_mul(c.into()))
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
@@ -376,32 +376,32 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `287`
// Estimated: `6098`
- // Minimum execution time: 26_278 nanoseconds.
- Weight::from_ref_time(26_682_000)
+ // Minimum execution time: 26_014 nanoseconds.
+ Weight::from_ref_time(26_510_000)
.saturating_add(Weight::from_proof_size(6098))
.saturating_add(T::DbWeight::get().reads(2_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
}
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts OwnerInfoOf (r:2 w:2)
/// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured)
/// Storage: System EventTopics (r:3 w:3)
/// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured)
fn set_code() -> Weight {
// Proof Size summary in bytes:
- // Measured: `634`
- // Estimated: `16752`
- // Minimum execution time: 30_223 nanoseconds.
- Weight::from_ref_time(30_737_000)
- .saturating_add(Weight::from_proof_size(16752))
+ // Measured: `666`
+ // Estimated: `16848`
+ // Minimum execution time: 30_177 nanoseconds.
+ Weight::from_ref_time(30_639_000)
+ .saturating_add(Weight::from_proof_size(16848))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(6_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -411,13 +411,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_caller(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `845 + r * (480 ±0)`
- // Estimated: `17120 + r * (2400 ±0)`
- // Minimum execution time: 374_780 nanoseconds.
- Weight::from_ref_time(379_468_453)
- .saturating_add(Weight::from_proof_size(17120))
- // Standard Error: 45_809
- .saturating_add(Weight::from_ref_time(17_553_577).saturating_mul(r.into()))
+ // Measured: `877 + r * (480 ±0)`
+ // Estimated: `17295 + r * (2400 ±0)`
+ // Minimum execution time: 373_786 nanoseconds.
+ Weight::from_ref_time(377_332_691)
+ .saturating_add(Weight::from_proof_size(17295))
+ // Standard Error: 51_211
+ .saturating_add(Weight::from_ref_time(17_715_615).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -425,7 +425,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -435,22 +435,22 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_is_contract(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `882 + r * (19218 ±0)`
- // Estimated: `17110 + r * (294100 ±0)`
- // Minimum execution time: 374_399 nanoseconds.
- Weight::from_ref_time(228_569_211)
- .saturating_add(Weight::from_proof_size(17110))
- // Standard Error: 492_562
- .saturating_add(Weight::from_ref_time(251_682_897).saturating_mul(r.into()))
+ // Measured: `917 + r * (21778 ±0)`
+ // Estimated: `17295 + r * (306895 ±0)`
+ // Minimum execution time: 374_009 nanoseconds.
+ Weight::from_ref_time(238_991_986)
+ .saturating_add(Weight::from_proof_size(17295))
+ // Standard Error: 464_711
+ .saturating_add(Weight::from_ref_time(249_099_538).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(294100).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(306895).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -460,22 +460,22 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_code_hash(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `889 + r * (19539 ±0)`
- // Estimated: `17170 + r * (295700 ±0)`
- // Minimum execution time: 375_980 nanoseconds.
- Weight::from_ref_time(232_604_331)
- .saturating_add(Weight::from_proof_size(17170))
- // Standard Error: 491_912
- .saturating_add(Weight::from_ref_time(299_479_335).saturating_mul(r.into()))
+ // Measured: `921 + r * (22099 ±0)`
+ // Estimated: `17340 + r * (308500 ±0)`
+ // Minimum execution time: 375_058 nanoseconds.
+ Weight::from_ref_time(238_765_068)
+ .saturating_add(Weight::from_proof_size(17340))
+ // Standard Error: 662_617
+ .saturating_add(Weight::from_ref_time(302_175_089).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(295700).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(308500).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -485,13 +485,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_own_code_hash(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `852 + r * (480 ±0)`
- // Estimated: `17155 + r * (2400 ±0)`
- // Minimum execution time: 375_075 nanoseconds.
- Weight::from_ref_time(381_217_372)
- .saturating_add(Weight::from_proof_size(17155))
- // Standard Error: 63_950
- .saturating_add(Weight::from_ref_time(21_872_316).saturating_mul(r.into()))
+ // Measured: `884 + r * (480 ±0)`
+ // Estimated: `17330 + r * (2400 ±0)`
+ // Minimum execution time: 374_747 nanoseconds.
+ Weight::from_ref_time(376_482_380)
+ .saturating_add(Weight::from_proof_size(17330))
+ // Standard Error: 61_919
+ .saturating_add(Weight::from_ref_time(22_376_795).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -499,7 +499,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -509,13 +509,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_caller_is_origin(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842 + r * (240 ±0)`
- // Estimated: `17080 + r * (1200 ±0)`
- // Minimum execution time: 373_260 nanoseconds.
- Weight::from_ref_time(377_987_666)
- .saturating_add(Weight::from_proof_size(17080))
- // Standard Error: 35_603
- .saturating_add(Weight::from_ref_time(11_274_165).saturating_mul(r.into()))
+ // Measured: `874 + r * (240 ±0)`
+ // Estimated: `17265 + r * (1200 ±0)`
+ // Minimum execution time: 372_287 nanoseconds.
+ Weight::from_ref_time(376_250_858)
+ .saturating_add(Weight::from_proof_size(17265))
+ // Standard Error: 40_119
+ .saturating_add(Weight::from_ref_time(11_359_647).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into()))
@@ -523,7 +523,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -533,13 +533,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_address(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `846 + r * (480 ±0)`
- // Estimated: `17100 + r * (2400 ±0)`
- // Minimum execution time: 374_605 nanoseconds.
- Weight::from_ref_time(379_395_443)
- .saturating_add(Weight::from_proof_size(17100))
- // Standard Error: 49_646
- .saturating_add(Weight::from_ref_time(17_487_585).saturating_mul(r.into()))
+ // Measured: `878 + r * (480 ±0)`
+ // Estimated: `17260 + r * (2400 ±0)`
+ // Minimum execution time: 374_445 nanoseconds.
+ Weight::from_ref_time(377_243_521)
+ .saturating_add(Weight::from_proof_size(17260))
+ // Standard Error: 53_032
+ .saturating_add(Weight::from_ref_time(17_684_246).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -547,7 +547,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -557,21 +557,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_gas_left(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `847 + r * (480 ±0)`
- // Estimated: `17105 + r * (2400 ±0)`
- // Minimum execution time: 374_620 nanoseconds.
- Weight::from_ref_time(379_623_792)
- .saturating_add(Weight::from_proof_size(17105))
- // Standard Error: 49_990
- .saturating_add(Weight::from_ref_time(17_226_706).saturating_mul(r.into()))
+ // Measured: `879 + r * (480 ±0)`
+ // Estimated: `17250 + r * (2405 ±0)`
+ // Minimum execution time: 374_029 nanoseconds.
+ Weight::from_ref_time(380_415_186)
+ .saturating_add(Weight::from_proof_size(17250))
+ // Standard Error: 60_562
+ .saturating_add(Weight::from_ref_time(17_152_599).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(2405).saturating_mul(r.into()))
}
/// Storage: System Account (r:2 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -581,13 +581,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_balance(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1017 + r * (480 ±0)`
- // Estimated: `19673 + r * (2456 ±4)`
- // Minimum execution time: 374_002 nanoseconds.
- Weight::from_ref_time(384_615_649)
- .saturating_add(Weight::from_proof_size(19673))
- // Standard Error: 85_633
- .saturating_add(Weight::from_ref_time(95_227_118).saturating_mul(r.into()))
+ // Measured: `1049 + r * (480 ±0)`
+ // Estimated: `19849 + r * (2456 ±0)`
+ // Minimum execution time: 373_999 nanoseconds.
+ Weight::from_ref_time(381_757_033)
+ .saturating_add(Weight::from_proof_size(19849))
+ // Standard Error: 97_983
+ .saturating_add(Weight::from_ref_time(98_290_984).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2456).saturating_mul(r.into()))
@@ -595,7 +595,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -605,13 +605,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_value_transferred(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `856 + r * (480 ±0)`
- // Estimated: `17200 + r * (2400 ±0)`
- // Minimum execution time: 375_307 nanoseconds.
- Weight::from_ref_time(378_389_705)
- .saturating_add(Weight::from_proof_size(17200))
- // Standard Error: 42_265
- .saturating_add(Weight::from_ref_time(17_316_680).saturating_mul(r.into()))
+ // Measured: `888 + r * (480 ±0)`
+ // Estimated: `17360 + r * (2400 ±0)`
+ // Minimum execution time: 374_197 nanoseconds.
+ Weight::from_ref_time(377_755_896)
+ .saturating_add(Weight::from_proof_size(17360))
+ // Standard Error: 60_542
+ .saturating_add(Weight::from_ref_time(17_442_065).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -619,7 +619,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -629,13 +629,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_minimum_balance(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `854 + r * (480 ±0)`
- // Estimated: `17140 + r * (2400 ±0)`
- // Minimum execution time: 374_878 nanoseconds.
- Weight::from_ref_time(379_364_066)
- .saturating_add(Weight::from_proof_size(17140))
- // Standard Error: 49_158
- .saturating_add(Weight::from_ref_time(17_111_145).saturating_mul(r.into()))
+ // Measured: `886 + r * (480 ±0)`
+ // Estimated: `17290 + r * (2400 ±0)`
+ // Minimum execution time: 373_888 nanoseconds.
+ Weight::from_ref_time(377_825_771)
+ .saturating_add(Weight::from_proof_size(17290))
+ // Standard Error: 38_026
+ .saturating_add(Weight::from_ref_time(17_147_903).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -643,7 +643,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -653,13 +653,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_block_number(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `851 + r * (480 ±0)`
- // Estimated: `17125 + r * (2400 ±0)`
- // Minimum execution time: 374_981 nanoseconds.
- Weight::from_ref_time(381_539_022)
- .saturating_add(Weight::from_proof_size(17125))
- // Standard Error: 61_419
- .saturating_add(Weight::from_ref_time(17_062_381).saturating_mul(r.into()))
+ // Measured: `883 + r * (480 ±0)`
+ // Estimated: `17315 + r * (2400 ±0)`
+ // Minimum execution time: 373_904 nanoseconds.
+ Weight::from_ref_time(378_652_372)
+ .saturating_add(Weight::from_proof_size(17315))
+ // Standard Error: 43_833
+ .saturating_add(Weight::from_ref_time(16_936_781).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -667,7 +667,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -677,13 +677,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_now(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842 + r * (480 ±0)`
- // Estimated: `17100 + r * (2400 ±0)`
- // Minimum execution time: 374_798 nanoseconds.
- Weight::from_ref_time(372_659_915)
- .saturating_add(Weight::from_proof_size(17100))
- // Standard Error: 151_499
- .saturating_add(Weight::from_ref_time(18_192_683).saturating_mul(r.into()))
+ // Measured: `874 + r * (480 ±0)`
+ // Estimated: `17245 + r * (2400 ±0)`
+ // Minimum execution time: 373_473 nanoseconds.
+ Weight::from_ref_time(376_386_312)
+ .saturating_add(Weight::from_proof_size(17245))
+ // Standard Error: 46_945
+ .saturating_add(Weight::from_ref_time(17_336_462).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -691,7 +691,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -703,13 +703,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_weight_to_fee(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `919 + r * (800 ±0)`
- // Estimated: `18835 + r * (4805 ±0)`
- // Minimum execution time: 374_841 nanoseconds.
- Weight::from_ref_time(385_475_889)
- .saturating_add(Weight::from_proof_size(18835))
- // Standard Error: 106_207
- .saturating_add(Weight::from_ref_time(88_099_987).saturating_mul(r.into()))
+ // Measured: `951 + r * (800 ±0)`
+ // Estimated: `19046 + r * (4805 ±0)`
+ // Minimum execution time: 373_661 nanoseconds.
+ Weight::from_ref_time(385_824_015)
+ .saturating_add(Weight::from_proof_size(19046))
+ // Standard Error: 75_964
+ .saturating_add(Weight::from_ref_time(88_530_074).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into()))
@@ -717,7 +717,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -727,13 +727,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_gas(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `809 + r * (320 ±0)`
- // Estimated: `16955 + r * (1600 ±0)`
- // Minimum execution time: 134_436 nanoseconds.
- Weight::from_ref_time(137_789_498)
- .saturating_add(Weight::from_proof_size(16955))
- // Standard Error: 10_622
- .saturating_add(Weight::from_ref_time(8_144_024).saturating_mul(r.into()))
+ // Measured: `841 + r * (320 ±0)`
+ // Estimated: `17120 + r * (1600 ±0)`
+ // Minimum execution time: 133_849 nanoseconds.
+ Weight::from_ref_time(137_283_391)
+ .saturating_add(Weight::from_proof_size(17120))
+ // Standard Error: 13_312
+ .saturating_add(Weight::from_ref_time(8_055_328).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(1600).saturating_mul(r.into()))
@@ -741,7 +741,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -751,13 +751,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_input(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `844 + r * (480 ±0)`
- // Estimated: `17085 + r * (2400 ±0)`
- // Minimum execution time: 374_480 nanoseconds.
- Weight::from_ref_time(379_723_392)
- .saturating_add(Weight::from_proof_size(17085))
- // Standard Error: 50_240
- .saturating_add(Weight::from_ref_time(15_358_041).saturating_mul(r.into()))
+ // Measured: `876 + r * (480 ±0)`
+ // Estimated: `17245 + r * (2400 ±0)`
+ // Minimum execution time: 373_468 nanoseconds.
+ Weight::from_ref_time(376_121_093)
+ .saturating_add(Weight::from_proof_size(17245))
+ // Standard Error: 61_857
+ .saturating_add(Weight::from_ref_time(15_868_414).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -765,7 +765,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -775,20 +775,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 1024]`.
fn seal_input_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1324`
- // Estimated: `19490`
- // Minimum execution time: 392_282 nanoseconds.
- Weight::from_ref_time(418_943_323)
- .saturating_add(Weight::from_proof_size(19490))
- // Standard Error: 4_673
- .saturating_add(Weight::from_ref_time(9_664_301).saturating_mul(n.into()))
+ // Measured: `1356`
+ // Estimated: `19650`
+ // Minimum execution time: 390_668 nanoseconds.
+ Weight::from_ref_time(419_608_449)
+ .saturating_add(Weight::from_proof_size(19650))
+ // Standard Error: 4_890
+ .saturating_add(Weight::from_ref_time(9_672_288).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -798,11 +798,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_return(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `832 + r * (45 ±0)`
- // Estimated: `17030 + r * (225 ±0)`
- // Minimum execution time: 372_207 nanoseconds.
- Weight::from_ref_time(376_232_444)
- .saturating_add(Weight::from_proof_size(17030))
+ // Measured: `864 + r * (45 ±0)`
+ // Estimated: `17190 + r * (225 ±0)`
+ // Minimum execution time: 371_309 nanoseconds.
+ Weight::from_ref_time(373_625_402)
+ .saturating_add(Weight::from_proof_size(17190))
+ // Standard Error: 419_605
+ .saturating_add(Weight::from_ref_time(1_737_397).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(225).saturating_mul(r.into()))
@@ -810,7 +812,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -820,20 +822,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 1024]`.
fn seal_return_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842`
- // Estimated: `17125`
- // Minimum execution time: 374_743 nanoseconds.
- Weight::from_ref_time(377_365_053)
- .saturating_add(Weight::from_proof_size(17125))
- // Standard Error: 1_073
- .saturating_add(Weight::from_ref_time(231_251).saturating_mul(n.into()))
+ // Measured: `874`
+ // Estimated: `17285`
+ // Minimum execution time: 374_094 nanoseconds.
+ Weight::from_ref_time(375_965_200)
+ .saturating_add(Weight::from_proof_size(17285))
+ // Standard Error: 1_127
+ .saturating_add(Weight::from_ref_time(232_645).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
- /// Storage: System Account (r:3 w:3)
+ /// Storage: System Account (r:4 w:4)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -847,23 +849,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_terminate(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `874 + r * (280 ±0)`
- // Estimated: `19880 + r * (11465 ±0)`
- // Minimum execution time: 374_873 nanoseconds.
- Weight::from_ref_time(378_422_289)
- .saturating_add(Weight::from_proof_size(19880))
- // Standard Error: 979_734
- .saturating_add(Weight::from_ref_time(57_035_310).saturating_mul(r.into()))
+ // Measured: `906 + r * (452 ±0)`
+ // Estimated: `20242 + r * (15004 ±0)`
+ // Minimum execution time: 373_123 nanoseconds.
+ Weight::from_ref_time(374_924_634)
+ .saturating_add(Weight::from_proof_size(20242))
+ // Standard Error: 378_010
+ .saturating_add(Weight::from_ref_time(70_441_665).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
- .saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(r.into())))
+ .saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(T::DbWeight::get().writes((6_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(11465).saturating_mul(r.into()))
+ .saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(r.into())))
+ .saturating_add(Weight::from_proof_size(15004).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -875,13 +877,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_random(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `889 + r * (800 ±0)`
- // Estimated: `18643 + r * (4805 ±0)`
- // Minimum execution time: 375_001 nanoseconds.
- Weight::from_ref_time(382_558_599)
- .saturating_add(Weight::from_proof_size(18643))
- // Standard Error: 94_918
- .saturating_add(Weight::from_ref_time(112_973_277).saturating_mul(r.into()))
+ // Measured: `921 + r * (800 ±0)`
+ // Estimated: `18835 + r * (4805 ±0)`
+ // Minimum execution time: 373_291 nanoseconds.
+ Weight::from_ref_time(385_684_344)
+ .saturating_add(Weight::from_proof_size(18835))
+ // Standard Error: 99_025
+ .saturating_add(Weight::from_ref_time(111_308_793).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into()))
@@ -889,7 +891,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -899,13 +901,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_deposit_event(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842 + r * (800 ±0)`
- // Estimated: `17075 + r * (4000 ±0)`
- // Minimum execution time: 372_547 nanoseconds.
- Weight::from_ref_time(383_278_916)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 128_339
- .saturating_add(Weight::from_ref_time(229_356_088).saturating_mul(r.into()))
+ // Measured: `874 + r * (800 ±0)`
+ // Estimated: `17250 + r * (4000 ±0)`
+ // Minimum execution time: 371_900 nanoseconds.
+ Weight::from_ref_time(384_166_626)
+ .saturating_add(Weight::from_proof_size(17250))
+ // Standard Error: 205_255
+ .saturating_add(Weight::from_ref_time(229_214_157).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(4000).saturating_mul(r.into()))
@@ -913,7 +915,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -924,15 +926,15 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 16]`.
fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1778 + t * (2608 ±0) + n * (8 ±0)`
- // Estimated: `21675 + t * (211030 ±0) + n * (50 ±0)`
- // Minimum execution time: 1_290_432 nanoseconds.
- Weight::from_ref_time(595_859_216)
- .saturating_add(Weight::from_proof_size(21675))
- // Standard Error: 602_943
- .saturating_add(Weight::from_ref_time(178_128_149).saturating_mul(t.into()))
- // Standard Error: 165_597
- .saturating_add(Weight::from_ref_time(71_475_468).saturating_mul(n.into()))
+ // Measured: `1821 + t * (2608 ±0) + n * (7 ±0)`
+ // Estimated: `21870 + t * (211030 ±0) + n * (50 ±0)`
+ // Minimum execution time: 1_289_873 nanoseconds.
+ Weight::from_ref_time(581_702_206)
+ .saturating_add(Weight::from_proof_size(21870))
+ // Standard Error: 665_638
+ .saturating_add(Weight::from_ref_time(181_470_553).saturating_mul(t.into()))
+ // Standard Error: 182_816
+ .saturating_add(Weight::from_ref_time(71_635_250).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(t.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
@@ -943,7 +945,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -953,13 +955,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_debug_message(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (560 ±0)`
- // Estimated: `17065 + r * (2800 ±0)`
- // Minimum execution time: 149_020 nanoseconds.
- Weight::from_ref_time(152_893_012)
- .saturating_add(Weight::from_proof_size(17065))
- // Standard Error: 31_804
- .saturating_add(Weight::from_ref_time(14_497_512).saturating_mul(r.into()))
+ // Measured: `873 + r * (560 ±0)`
+ // Estimated: `17240 + r * (2800 ±0)`
+ // Minimum execution time: 148_635 nanoseconds.
+ Weight::from_ref_time(154_095_712)
+ .saturating_add(Weight::from_proof_size(17240))
+ // Standard Error: 77_790
+ .saturating_add(Weight::from_ref_time(14_837_085).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2800).saturating_mul(r.into()))
@@ -967,7 +969,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: MaxEncodedLen)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: MaxEncodedLen)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: MaxEncodedLen)
/// Storage: Timestamp Now (r:1 w:0)
@@ -977,13 +979,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `i` is `[0, 1024]`.
fn seal_debug_message_per_kb(i: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `125792`
- // Estimated: `265059`
- // Minimum execution time: 502_589 nanoseconds.
- Weight::from_ref_time(506_695_307)
- .saturating_add(Weight::from_proof_size(265059))
- // Standard Error: 2_148
- .saturating_add(Weight::from_ref_time(814_647).saturating_mul(i.into()))
+ // Measured: `125824`
+ // Estimated: `265128`
+ // Minimum execution time: 501_014 nanoseconds.
+ Weight::from_ref_time(505_634_218)
+ .saturating_add(Weight::from_proof_size(265128))
+ // Standard Error: 2_441
+ .saturating_add(Weight::from_ref_time(819_257).saturating_mul(i.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
@@ -992,85 +994,85 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 10]`.
fn seal_set_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `883 + r * (23417 ±0)`
- // Estimated: `883 + r * (23417 ±0)`
- // Minimum execution time: 375_473 nanoseconds.
- Weight::from_ref_time(291_125_810)
- .saturating_add(Weight::from_proof_size(883))
- // Standard Error: 824_971
- .saturating_add(Weight::from_ref_time(477_999_695).saturating_mul(r.into()))
+ // Measured: `911 + r * (23420 ±0)`
+ // Estimated: `911 + r * (23418 ±0)`
+ // Minimum execution time: 375_301 nanoseconds.
+ Weight::from_ref_time(291_498_841)
+ .saturating_add(Weight::from_proof_size(911))
+ // Standard Error: 809_989
+ .saturating_add(Weight::from_ref_time(464_550_291).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(T::DbWeight::get().writes((80_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(23417).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23418).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_set_storage_per_new_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `12583 + n * (11969 ±0)`
- // Estimated: `8500 + n * (12813 ±61)`
- // Minimum execution time: 515_962 nanoseconds.
- Weight::from_ref_time(697_904_030)
- .saturating_add(Weight::from_proof_size(8500))
- // Standard Error: 1_684_000
- .saturating_add(Weight::from_ref_time(98_411_710).saturating_mul(n.into()))
+ // Measured: `12672 + n * (11945 ±0)`
+ // Estimated: `8529 + n * (12814 ±61)`
+ // Minimum execution time: 506_318 nanoseconds.
+ Weight::from_ref_time(676_935_313)
+ .saturating_add(Weight::from_proof_size(8529))
+ // Standard Error: 1_589_291
+ .saturating_add(Weight::from_ref_time(97_839_399).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(52_u64))
.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(T::DbWeight::get().writes(50_u64))
.saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(n.into())))
- .saturating_add(Weight::from_proof_size(12813).saturating_mul(n.into()))
+ .saturating_add(Weight::from_proof_size(12814).saturating_mul(n.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_set_storage_per_old_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `15138 + n * (175775 ±0)`
- // Estimated: `9898 + n * (176855 ±74)`
- // Minimum execution time: 515_828 nanoseconds.
- Weight::from_ref_time(661_240_495)
- .saturating_add(Weight::from_proof_size(9898))
- // Standard Error: 1_338_661
- .saturating_add(Weight::from_ref_time(65_767_819).saturating_mul(n.into()))
+ // Measured: `15170 + n * (175775 ±0)`
+ // Estimated: `9914 + n * (176858 ±74)`
+ // Minimum execution time: 506_148 nanoseconds.
+ Weight::from_ref_time(648_278_778)
+ .saturating_add(Weight::from_proof_size(9914))
+ // Standard Error: 1_343_586
+ .saturating_add(Weight::from_ref_time(65_789_595).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(51_u64))
.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(T::DbWeight::get().writes(49_u64))
.saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(n.into())))
- .saturating_add(Weight::from_proof_size(176855).saturating_mul(n.into()))
+ .saturating_add(Weight::from_proof_size(176858).saturating_mul(n.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `r` is `[0, 10]`.
fn seal_clear_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `876 + r * (23098 ±0)`
- // Estimated: `881 + r * (23097 ±0)`
- // Minimum execution time: 375_528 nanoseconds.
- Weight::from_ref_time(296_453_612)
- .saturating_add(Weight::from_proof_size(881))
- // Standard Error: 809_232
- .saturating_add(Weight::from_ref_time(465_365_815).saturating_mul(r.into()))
+ // Measured: `903 + r * (23099 ±0)`
+ // Estimated: `908 + r * (23099 ±0)`
+ // Minimum execution time: 374_344 nanoseconds.
+ Weight::from_ref_time(293_272_061)
+ .saturating_add(Weight::from_proof_size(908))
+ // Standard Error: 810_412
+ .saturating_add(Weight::from_ref_time(453_315_956).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(T::DbWeight::get().writes((80_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(23097).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_clear_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `14863 + n * (175768 ±0)`
- // Estimated: `9519 + n * (176867 ±75)`
- // Minimum execution time: 480_427 nanoseconds.
- Weight::from_ref_time(640_337_570)
- .saturating_add(Weight::from_proof_size(9519))
- // Standard Error: 1_497_141
- .saturating_add(Weight::from_ref_time(67_963_696).saturating_mul(n.into()))
+ // Measured: `14895 + n * (175768 ±0)`
+ // Estimated: `9551 + n * (176867 ±75)`
+ // Minimum execution time: 478_564 nanoseconds.
+ Weight::from_ref_time(630_839_142)
+ .saturating_add(Weight::from_proof_size(9551))
+ // Standard Error: 1_427_520
+ .saturating_add(Weight::from_ref_time(66_813_592).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(51_u64))
.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(T::DbWeight::get().writes(48_u64))
@@ -1082,30 +1084,30 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 10]`.
fn seal_get_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `878 + r * (23740 ±0)`
- // Estimated: `880 + r * (23739 ±0)`
- // Minimum execution time: 375_725 nanoseconds.
- Weight::from_ref_time(307_839_394)
- .saturating_add(Weight::from_proof_size(880))
- // Standard Error: 710_694
- .saturating_add(Weight::from_ref_time(381_738_407).saturating_mul(r.into()))
+ // Measured: `896 + r * (23744 ±0)`
+ // Estimated: `909 + r * (23740 ±0)`
+ // Minimum execution time: 374_479 nanoseconds.
+ Weight::from_ref_time(311_839_315)
+ .saturating_add(Weight::from_proof_size(909))
+ // Standard Error: 666_553
+ .saturating_add(Weight::from_ref_time(371_213_042).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(23739).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23740).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_get_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `15469 + n * (175775 ±0)`
- // Estimated: `10010 + n * (176900 ±76)`
- // Minimum execution time: 461_871 nanoseconds.
- Weight::from_ref_time(605_755_493)
- .saturating_add(Weight::from_proof_size(10010))
- // Standard Error: 1_375_044
- .saturating_add(Weight::from_ref_time(161_332_330).saturating_mul(n.into()))
+ // Measured: `15501 + n * (175775 ±0)`
+ // Estimated: `10042 + n * (176900 ±76)`
+ // Minimum execution time: 460_639 nanoseconds.
+ Weight::from_ref_time(591_187_094)
+ .saturating_add(Weight::from_proof_size(10042))
+ // Standard Error: 1_233_792
+ .saturating_add(Weight::from_ref_time(160_874_477).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(51_u64))
.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
@@ -1116,47 +1118,47 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 10]`.
fn seal_contains_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `871 + r * (23100 ±0)`
- // Estimated: `873 + r * (23099 ±0)`
- // Minimum execution time: 375_325 nanoseconds.
- Weight::from_ref_time(305_508_307)
- .saturating_add(Weight::from_proof_size(873))
- // Standard Error: 715_627
- .saturating_add(Weight::from_ref_time(369_985_438).saturating_mul(r.into()))
+ // Measured: `914 + r * (23098 ±0)`
+ // Estimated: `920 + r * (23098 ±0)`
+ // Minimum execution time: 374_272 nanoseconds.
+ Weight::from_ref_time(311_446_269)
+ .saturating_add(Weight::from_proof_size(920))
+ // Standard Error: 630_307
+ .saturating_add(Weight::from_ref_time(357_134_931).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23098).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_contains_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `14814 + n * (175782 ±0)`
- // Estimated: `9502 + n * (176872 ±75)`
- // Minimum execution time: 457_128 nanoseconds.
- Weight::from_ref_time(582_799_799)
- .saturating_add(Weight::from_proof_size(9502))
- // Standard Error: 1_151_126
- .saturating_add(Weight::from_ref_time(63_425_277).saturating_mul(n.into()))
+ // Measured: `14839 + n * (175789 ±0)`
+ // Estimated: `9532 + n * (176874 ±75)`
+ // Minimum execution time: 456_013 nanoseconds.
+ Weight::from_ref_time(575_116_352)
+ .saturating_add(Weight::from_proof_size(9532))
+ // Standard Error: 1_122_298
+ .saturating_add(Weight::from_ref_time(61_786_107).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(51_u64))
.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(176872).saturating_mul(n.into()))
+ .saturating_add(Weight::from_proof_size(176874).saturating_mul(n.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `r` is `[0, 10]`.
fn seal_take_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `879 + r * (23740 ±0)`
- // Estimated: `881 + r * (23739 ±0)`
- // Minimum execution time: 375_918 nanoseconds.
- Weight::from_ref_time(293_217_646)
- .saturating_add(Weight::from_proof_size(881))
- // Standard Error: 840_266
- .saturating_add(Weight::from_ref_time(478_374_701).saturating_mul(r.into()))
+ // Measured: `911 + r * (23740 ±0)`
+ // Estimated: `913 + r * (23739 ±0)`
+ // Minimum execution time: 374_621 nanoseconds.
+ Weight::from_ref_time(299_689_489)
+ .saturating_add(Weight::from_proof_size(913))
+ // Standard Error: 757_735
+ .saturating_add(Weight::from_ref_time(465_213_246).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
@@ -1168,13 +1170,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 8]`.
fn seal_take_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `15470 + n * (175775 ±0)`
- // Estimated: `10010 + n * (176898 ±76)`
- // Minimum execution time: 484_207 nanoseconds.
- Weight::from_ref_time(664_065_436)
- .saturating_add(Weight::from_proof_size(10010))
- // Standard Error: 1_655_442
- .saturating_add(Weight::from_ref_time(166_258_757).saturating_mul(n.into()))
+ // Measured: `15502 + n * (175775 ±0)`
+ // Estimated: `10042 + n * (176898 ±76)`
+ // Minimum execution time: 481_980 nanoseconds.
+ Weight::from_ref_time(647_289_053)
+ .saturating_add(Weight::from_proof_size(10042))
+ // Standard Error: 1_556_155
+ .saturating_add(Weight::from_ref_time(166_592_657).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(51_u64))
.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(T::DbWeight::get().writes(48_u64))
@@ -1184,7 +1186,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1602 w:1601)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1194,23 +1196,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_transfer(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1393 + r * (3602 ±0)`
- // Estimated: `21258 + r * (216091 ±0)`
- // Minimum execution time: 377_152 nanoseconds.
- Weight::from_ref_time(317_470_910)
- .saturating_add(Weight::from_proof_size(21258))
- // Standard Error: 994_076
- .saturating_add(Weight::from_ref_time(1_409_416_087).saturating_mul(r.into()))
+ // Measured: `1457 + r * (3604 ±0)`
+ // Estimated: `21583 + r * (216101 ±0)`
+ // Minimum execution time: 374_962 nanoseconds.
+ Weight::from_ref_time(313_416_386)
+ .saturating_add(Weight::from_proof_size(21583))
+ // Standard Error: 710_675
+ .saturating_add(Weight::from_ref_time(1_396_551_156).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(4_u64))
.saturating_add(T::DbWeight::get().writes((80_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(216091).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(216101).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1601)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:2 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1220,23 +1222,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_call(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1551 + r * (20511 ±0)`
- // Estimated: `21848 + r * (498651 ±1)`
- // Minimum execution time: 376_257 nanoseconds.
- Weight::from_ref_time(377_035_000)
- .saturating_add(Weight::from_proof_size(21848))
- // Standard Error: 7_966_778
- .saturating_add(Weight::from_ref_time(28_873_495_129).saturating_mul(r.into()))
+ // Measured: `1609 + r * (23073 ±0)`
+ // Estimated: `22098 + r * (511456 ±1)`
+ // Minimum execution time: 375_916 nanoseconds.
+ Weight::from_ref_time(376_468_000)
+ .saturating_add(Weight::from_proof_size(22098))
+ // Standard Error: 7_246_855
+ .saturating_add(Weight::from_ref_time(28_982_425_139).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().reads((160_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(T::DbWeight::get().writes((160_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(498651).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(511456).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1536 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1247,22 +1249,22 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
fn seal_delegate_call(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0 + r * (71670 ±0)`
- // Estimated: `17125 + r * (659927 ±822)`
- // Minimum execution time: 376_544 nanoseconds.
- Weight::from_ref_time(377_490_000)
- .saturating_add(Weight::from_proof_size(17125))
- // Standard Error: 8_608_050
- .saturating_add(Weight::from_ref_time(28_568_714_410).saturating_mul(r.into()))
+ // Estimated: `17285 + r * (659930 ±563)`
+ // Minimum execution time: 375_412 nanoseconds.
+ Weight::from_ref_time(376_493_000)
+ .saturating_add(Weight::from_proof_size(17285))
+ // Standard Error: 8_239_575
+ .saturating_add(Weight::from_ref_time(28_716_347_183).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((150_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(T::DbWeight::get().writes((75_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(659927).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(659930).saturating_mul(r.into()))
}
/// Storage: System Account (r:82 w:81)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:81 w:81)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:2 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1273,25 +1275,25 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `c` is `[0, 1024]`.
fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `21611 + t * (15369 ±0)`
- // Estimated: `519400 + t * (277320 ±0)`
- // Minimum execution time: 10_322_052 nanoseconds.
- Weight::from_ref_time(9_248_652_894)
- .saturating_add(Weight::from_proof_size(519400))
- // Standard Error: 9_039_638
- .saturating_add(Weight::from_ref_time(1_393_054_441).saturating_mul(t.into()))
- // Standard Error: 13_554
- .saturating_add(Weight::from_ref_time(9_819_606).saturating_mul(c.into()))
+ // Measured: `24269 + t * (16910 ±0)`
+ // Estimated: `532690 + t * (285025 ±0)`
+ // Minimum execution time: 10_443_315 nanoseconds.
+ Weight::from_ref_time(9_342_574_069)
+ .saturating_add(Weight::from_proof_size(532690))
+ // Standard Error: 7_237_279
+ .saturating_add(Weight::from_ref_time(1_390_221_936).saturating_mul(t.into()))
+ // Standard Error: 10_851
+ .saturating_add(Weight::from_ref_time(9_842_151).saturating_mul(c.into()))
.saturating_add(T::DbWeight::get().reads(167_u64))
.saturating_add(T::DbWeight::get().reads((81_u64).saturating_mul(t.into())))
.saturating_add(T::DbWeight::get().writes(163_u64))
.saturating_add(T::DbWeight::get().writes((81_u64).saturating_mul(t.into())))
- .saturating_add(Weight::from_proof_size(277320).saturating_mul(t.into()))
+ .saturating_add(Weight::from_proof_size(285025).saturating_mul(t.into()))
}
- /// Storage: System Account (r:1602 w:1602)
+ /// Storage: System Account (r:3202 w:3202)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1601)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1601 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1305,23 +1307,23 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_instantiate(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1613 + r * (25576 ±0)`
- // Estimated: `25698 + r * (1169112 ±1)`
- // Minimum execution time: 376_639 nanoseconds.
- Weight::from_ref_time(377_892_000)
- .saturating_add(Weight::from_proof_size(25698))
- // Standard Error: 21_259_255
- .saturating_add(Weight::from_ref_time(34_131_174_956).saturating_mul(r.into()))
+ // Measured: `1775 + r * (25568 ±0)`
+ // Estimated: `26563 + r * (1367114 ±2)`
+ // Minimum execution time: 376_418 nanoseconds.
+ Weight::from_ref_time(377_292_000)
+ .saturating_add(Weight::from_proof_size(26563))
+ // Standard Error: 32_312_545
+ .saturating_add(Weight::from_ref_time(35_904_826_312).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(8_u64))
- .saturating_add(T::DbWeight::get().reads((400_u64).saturating_mul(r.into())))
+ .saturating_add(T::DbWeight::get().reads((480_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(5_u64))
- .saturating_add(T::DbWeight::get().writes((320_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(1169112).saturating_mul(r.into()))
+ .saturating_add(T::DbWeight::get().writes((400_u64).saturating_mul(r.into())))
+ .saturating_add(Weight::from_proof_size(1367114).saturating_mul(r.into()))
}
- /// Storage: System Account (r:82 w:82)
+ /// Storage: System Account (r:162 w:162)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:81 w:81)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:2 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1337,27 +1339,27 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `s` is `[0, 960]`.
fn seal_instantiate_per_transfer_input_salt_kb(t: u32, i: u32, s: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `5666 + t * (17 ±0)`
- // Estimated: `651914 + t * (2762 ±3)`
- // Minimum execution time: 130_366_376 nanoseconds.
- Weight::from_ref_time(9_844_607_874)
- .saturating_add(Weight::from_proof_size(651914))
- // Standard Error: 100_211_149
- .saturating_add(Weight::from_ref_time(390_481_449).saturating_mul(t.into()))
- // Standard Error: 163_416
- .saturating_add(Weight::from_ref_time(126_154_200).saturating_mul(i.into()))
- // Standard Error: 163_416
- .saturating_add(Weight::from_ref_time(126_430_874).saturating_mul(s.into()))
- .saturating_add(T::DbWeight::get().reads(249_u64))
+ // Measured: `5785 + t * (33 ±0)`
+ // Estimated: `850985 + t * (2671 ±3)`
+ // Minimum execution time: 132_157_340 nanoseconds.
+ Weight::from_ref_time(11_329_968_948)
+ .saturating_add(Weight::from_proof_size(850985))
+ // Standard Error: 99_102_968
+ .saturating_add(Weight::from_ref_time(84_719_458).saturating_mul(t.into()))
+ // Standard Error: 161_609
+ .saturating_add(Weight::from_ref_time(126_156_627).saturating_mul(i.into()))
+ // Standard Error: 161_609
+ .saturating_add(Weight::from_ref_time(126_628_313).saturating_mul(s.into()))
+ .saturating_add(T::DbWeight::get().reads(329_u64))
.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into())))
- .saturating_add(T::DbWeight::get().writes(246_u64))
+ .saturating_add(T::DbWeight::get().writes(326_u64))
.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into())))
- .saturating_add(Weight::from_proof_size(2762).saturating_mul(t.into()))
+ .saturating_add(Weight::from_proof_size(2671).saturating_mul(t.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1367,13 +1369,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_sha2_256(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `839 + r * (642 ±0)`
- // Estimated: `17065 + r * (3210 ±0)`
- // Minimum execution time: 373_848 nanoseconds.
- Weight::from_ref_time(375_974_597)
- .saturating_add(Weight::from_proof_size(17065))
- // Standard Error: 558_923
- .saturating_add(Weight::from_ref_time(42_648_202).saturating_mul(r.into()))
+ // Measured: `871 + r * (642 ±0)`
+ // Estimated: `17225 + r * (3210 ±0)`
+ // Minimum execution time: 373_559 nanoseconds.
+ Weight::from_ref_time(375_166_904)
+ .saturating_add(Weight::from_proof_size(17225))
+ // Standard Error: 125_024
+ .saturating_add(Weight::from_ref_time(42_291_595).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into()))
@@ -1381,7 +1383,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1391,20 +1393,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1641`
- // Estimated: `21000`
- // Minimum execution time: 417_281 nanoseconds.
- Weight::from_ref_time(418_086_000)
- .saturating_add(Weight::from_proof_size(21000))
- // Standard Error: 43_883
- .saturating_add(Weight::from_ref_time(324_497_460).saturating_mul(n.into()))
+ // Measured: `1673`
+ // Estimated: `21160`
+ // Minimum execution time: 416_233 nanoseconds.
+ Weight::from_ref_time(416_785_000)
+ .saturating_add(Weight::from_proof_size(21160))
+ // Standard Error: 56_223
+ .saturating_add(Weight::from_ref_time(324_513_835).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1414,13 +1416,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_keccak_256(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (642 ±0)`
- // Estimated: `17075 + r * (3210 ±0)`
- // Minimum execution time: 372_362 nanoseconds.
- Weight::from_ref_time(374_975_677)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 307_932
- .saturating_add(Weight::from_ref_time(57_607_522).saturating_mul(r.into()))
+ // Measured: `873 + r * (642 ±0)`
+ // Estimated: `17235 + r * (3210 ±0)`
+ // Minimum execution time: 371_735 nanoseconds.
+ Weight::from_ref_time(375_979_430)
+ .saturating_add(Weight::from_proof_size(17235))
+ // Standard Error: 968_037
+ .saturating_add(Weight::from_ref_time(57_780_769).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into()))
@@ -1428,7 +1430,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1438,20 +1440,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1643`
- // Estimated: `21040`
- // Minimum execution time: 431_034 nanoseconds.
- Weight::from_ref_time(431_571_000)
- .saturating_add(Weight::from_proof_size(21040))
- // Standard Error: 80_071
- .saturating_add(Weight::from_ref_time(261_645_325).saturating_mul(n.into()))
+ // Measured: `1675`
+ // Estimated: `21205`
+ // Minimum execution time: 428_196 nanoseconds.
+ Weight::from_ref_time(429_438_000)
+ .saturating_add(Weight::from_proof_size(21205))
+ // Standard Error: 57_860
+ .saturating_add(Weight::from_ref_time(260_917_896).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1461,13 +1463,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_blake2_256(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (642 ±0)`
- // Estimated: `17075 + r * (3210 ±0)`
- // Minimum execution time: 372_069 nanoseconds.
- Weight::from_ref_time(374_200_608)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 171_799
- .saturating_add(Weight::from_ref_time(32_843_391).saturating_mul(r.into()))
+ // Measured: `873 + r * (642 ±0)`
+ // Estimated: `17235 + r * (3210 ±0)`
+ // Minimum execution time: 371_412 nanoseconds.
+ Weight::from_ref_time(373_635_818)
+ .saturating_add(Weight::from_proof_size(17235))
+ // Standard Error: 222_973
+ .saturating_add(Weight::from_ref_time(33_347_181).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into()))
@@ -1475,7 +1477,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1485,20 +1487,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1643`
- // Estimated: `21010`
- // Minimum execution time: 406_143 nanoseconds.
- Weight::from_ref_time(406_744_000)
- .saturating_add(Weight::from_proof_size(21010))
- // Standard Error: 48_038
- .saturating_add(Weight::from_ref_time(103_286_295).saturating_mul(n.into()))
+ // Measured: `1675`
+ // Estimated: `21180`
+ // Minimum execution time: 405_858 nanoseconds.
+ Weight::from_ref_time(406_498_000)
+ .saturating_add(Weight::from_proof_size(21180))
+ // Standard Error: 48_388
+ .saturating_add(Weight::from_ref_time(103_283_157).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1508,13 +1510,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_blake2_128(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (679 ±0)`
- // Estimated: `17075 + r * (3395 ±0)`
- // Minimum execution time: 372_201 nanoseconds.
- Weight::from_ref_time(374_049_708)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 387_179
- .saturating_add(Weight::from_ref_time(38_857_191).saturating_mul(r.into()))
+ // Measured: `873 + r * (679 ±0)`
+ // Estimated: `17235 + r * (3395 ±0)`
+ // Minimum execution time: 371_746 nanoseconds.
+ Weight::from_ref_time(373_538_171)
+ .saturating_add(Weight::from_proof_size(17235))
+ // Standard Error: 387_332
+ .saturating_add(Weight::from_ref_time(35_933_528).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3395).saturating_mul(r.into()))
@@ -1522,7 +1524,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1532,20 +1534,20 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1643`
- // Estimated: `21050`
- // Minimum execution time: 405_819 nanoseconds.
- Weight::from_ref_time(406_364_000)
- .saturating_add(Weight::from_proof_size(21050))
- // Standard Error: 46_248
- .saturating_add(Weight::from_ref_time(103_189_157).saturating_mul(n.into()))
+ // Measured: `1675`
+ // Estimated: `21225`
+ // Minimum execution time: 405_752 nanoseconds.
+ Weight::from_ref_time(406_417_000)
+ .saturating_add(Weight::from_proof_size(21225))
+ // Standard Error: 47_051
+ .saturating_add(Weight::from_ref_time(103_325_027).saturating_mul(n.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1555,13 +1557,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_ecdsa_recover(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `885 + r * (6083 ±0)`
- // Estimated: `17295 + r * (30415 ±0)`
- // Minimum execution time: 374_836 nanoseconds.
- Weight::from_ref_time(379_385_500)
- .saturating_add(Weight::from_proof_size(17295))
- // Standard Error: 1_694_427
- .saturating_add(Weight::from_ref_time(3_021_801_000).saturating_mul(r.into()))
+ // Measured: `917 + r * (6083 ±0)`
+ // Estimated: `17455 + r * (30415 ±0)`
+ // Minimum execution time: 373_882 nanoseconds.
+ Weight::from_ref_time(376_553_787)
+ .saturating_add(Weight::from_proof_size(17455))
+ // Standard Error: 912_833
+ .saturating_add(Weight::from_ref_time(3_021_100_412).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(30415).saturating_mul(r.into()))
@@ -1569,7 +1571,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1579,13 +1581,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 1]`.
fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `854 + r * (3362 ±0)`
- // Estimated: `17140 + r * (16810 ±0)`
- // Minimum execution time: 374_223 nanoseconds.
- Weight::from_ref_time(376_120_230)
- .saturating_add(Weight::from_proof_size(17140))
- // Standard Error: 619_576
- .saturating_add(Weight::from_ref_time(754_257_969).saturating_mul(r.into()))
+ // Measured: `886 + r * (3362 ±0)`
+ // Estimated: `17300 + r * (16810 ±0)`
+ // Minimum execution time: 373_673 nanoseconds.
+ Weight::from_ref_time(375_712_961)
+ .saturating_add(Weight::from_proof_size(17300))
+ // Standard Error: 596_297
+ .saturating_add(Weight::from_ref_time(738_257_638).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(16810).saturating_mul(r.into()))
@@ -1593,7 +1595,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1536 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1606,12 +1608,12 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
fn seal_set_code_hash(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0 + r * (79300 ±0)`
- // Estimated: `64652 + r * (942952 ±829)`
- // Minimum execution time: 374_442 nanoseconds.
- Weight::from_ref_time(375_591_000)
- .saturating_add(Weight::from_proof_size(64652))
- // Standard Error: 3_764_193
- .saturating_add(Weight::from_ref_time(1_552_885_601).saturating_mul(r.into()))
+ // Estimated: `64844 + r * (942952 ±833)`
+ // Minimum execution time: 374_097 nanoseconds.
+ Weight::from_ref_time(374_985_000)
+ .saturating_add(Weight::from_proof_size(64844))
+ // Standard Error: 3_772_336
+ .saturating_add(Weight::from_ref_time(1_546_402_854).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().reads((225_u64).saturating_mul(r.into())))
.saturating_add(T::DbWeight::get().writes(3_u64))
@@ -1621,7 +1623,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1631,13 +1633,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_reentrance_count(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `837 + r * (240 ±0)`
- // Estimated: `17055 + r * (1200 ±0)`
- // Minimum execution time: 374_922 nanoseconds.
- Weight::from_ref_time(376_234_094)
- .saturating_add(Weight::from_proof_size(17055))
- // Standard Error: 45_995
- .saturating_add(Weight::from_ref_time(11_606_505).saturating_mul(r.into()))
+ // Measured: `869 + r * (240 ±0)`
+ // Estimated: `17215 + r * (1200 ±0)`
+ // Minimum execution time: 374_249 nanoseconds.
+ Weight::from_ref_time(377_990_998)
+ .saturating_add(Weight::from_proof_size(17215))
+ // Standard Error: 38_133
+ .saturating_add(Weight::from_ref_time(11_483_273).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into()))
@@ -1645,7 +1647,7 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1655,21 +1657,21 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_account_reentrance_count(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `2056 + r * (3153 ±0)`
- // Estimated: `21730 + r * (15870 ±2)`
- // Minimum execution time: 376_762 nanoseconds.
- Weight::from_ref_time(396_934_359)
- .saturating_add(Weight::from_proof_size(21730))
- // Standard Error: 68_263
- .saturating_add(Weight::from_ref_time(18_367_270).saturating_mul(r.into()))
+ // Measured: `2102 + r * (3154 ±0)`
+ // Estimated: `21980 + r * (15875 ±2)`
+ // Minimum execution time: 375_552 nanoseconds.
+ Weight::from_ref_time(400_624_032)
+ .saturating_add(Weight::from_proof_size(21980))
+ // Standard Error: 82_523
+ .saturating_add(Weight::from_ref_time(18_057_327).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(6_u64))
.saturating_add(T::DbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(15870).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(15875).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -1681,13 +1683,13 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
/// The range of component `r` is `[0, 20]`.
fn seal_instantiation_nonce(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `840 + r * (240 ±0)`
- // Estimated: `18405 + r * (1440 ±0)`
- // Minimum execution time: 374_257 nanoseconds.
- Weight::from_ref_time(380_453_380)
- .saturating_add(Weight::from_proof_size(18405))
- // Standard Error: 42_718
- .saturating_add(Weight::from_ref_time(9_355_253).saturating_mul(r.into()))
+ // Measured: `872 + r * (240 ±0)`
+ // Estimated: `18598 + r * (1440 ±0)`
+ // Minimum execution time: 373_899 nanoseconds.
+ Weight::from_ref_time(379_733_943)
+ .saturating_add(Weight::from_proof_size(18598))
+ // Standard Error: 32_022
+ .saturating_add(Weight::from_ref_time(9_381_180).saturating_mul(r.into()))
.saturating_add(T::DbWeight::get().reads(7_u64))
.saturating_add(T::DbWeight::get().writes(4_u64))
.saturating_add(Weight::from_proof_size(1440).saturating_mul(r.into()))
@@ -1697,572 +1699,572 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 788 nanoseconds.
- Weight::from_ref_time(1_209_829)
+ // Minimum execution time: 834 nanoseconds.
+ Weight::from_ref_time(1_009_646)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 3_436
- .saturating_add(Weight::from_ref_time(409_858).saturating_mul(r.into()))
+ // Standard Error: 388
+ .saturating_add(Weight::from_ref_time(411_979).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64load(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 955 nanoseconds.
- Weight::from_ref_time(1_526_327)
+ // Minimum execution time: 882 nanoseconds.
+ Weight::from_ref_time(1_416_377)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_399
- .saturating_add(Weight::from_ref_time(1_084_504).saturating_mul(r.into()))
+ // Standard Error: 1_133
+ .saturating_add(Weight::from_ref_time(1_075_838).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64store(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 967 nanoseconds.
- Weight::from_ref_time(1_576_183)
+ // Minimum execution time: 878 nanoseconds.
+ Weight::from_ref_time(1_343_056)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 5_719
- .saturating_add(Weight::from_ref_time(1_006_742).saturating_mul(r.into()))
+ // Standard Error: 426
+ .saturating_add(Weight::from_ref_time(1_001_214).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_select(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 849 nanoseconds.
- Weight::from_ref_time(1_106_539)
+ // Minimum execution time: 796 nanoseconds.
+ Weight::from_ref_time(1_079_086)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 445
- .saturating_add(Weight::from_ref_time(1_149_752).saturating_mul(r.into()))
+ // Standard Error: 409
+ .saturating_add(Weight::from_ref_time(1_149_188).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_if(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 829 nanoseconds.
- Weight::from_ref_time(1_171_360)
+ // Minimum execution time: 800 nanoseconds.
+ Weight::from_ref_time(1_044_184)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 552
- .saturating_add(Weight::from_ref_time(1_309_914).saturating_mul(r.into()))
+ // Standard Error: 707
+ .saturating_add(Weight::from_ref_time(1_315_686).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_br(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 835 nanoseconds.
- Weight::from_ref_time(1_125_578)
+ // Minimum execution time: 807 nanoseconds.
+ Weight::from_ref_time(1_049_633)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 374
- .saturating_add(Weight::from_ref_time(641_683).saturating_mul(r.into()))
+ // Standard Error: 361
+ .saturating_add(Weight::from_ref_time(640_530).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_br_if(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 816 nanoseconds.
- Weight::from_ref_time(1_032_093)
+ // Minimum execution time: 774 nanoseconds.
+ Weight::from_ref_time(1_124_053)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 811
- .saturating_add(Weight::from_ref_time(956_228).saturating_mul(r.into()))
+ // Standard Error: 784
+ .saturating_add(Weight::from_ref_time(949_398).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_br_table(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 801 nanoseconds.
- Weight::from_ref_time(816_764)
+ // Minimum execution time: 810 nanoseconds.
+ Weight::from_ref_time(676_581)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_669
- .saturating_add(Weight::from_ref_time(1_166_556).saturating_mul(r.into()))
+ // Standard Error: 2_356
+ .saturating_add(Weight::from_ref_time(1_163_465).saturating_mul(r.into()))
}
/// The range of component `e` is `[1, 256]`.
fn instr_br_table_per_entry(e: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_639 nanoseconds.
- Weight::from_ref_time(2_905_554)
+ // Minimum execution time: 2_580 nanoseconds.
+ Weight::from_ref_time(2_835_656)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 62
- .saturating_add(Weight::from_ref_time(4_438).saturating_mul(e.into()))
+ // Standard Error: 71
+ .saturating_add(Weight::from_ref_time(4_686).saturating_mul(e.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_call(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 831 nanoseconds.
- Weight::from_ref_time(1_729_584)
+ // Minimum execution time: 826 nanoseconds.
+ Weight::from_ref_time(1_625_698)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 33_753
- .saturating_add(Weight::from_ref_time(2_380_315).saturating_mul(r.into()))
+ // Standard Error: 1_740
+ .saturating_add(Weight::from_ref_time(2_332_187).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_call_indirect(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 964 nanoseconds.
- Weight::from_ref_time(2_445_291)
+ // Minimum execution time: 901 nanoseconds.
+ Weight::from_ref_time(2_338_620)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 3_285
- .saturating_add(Weight::from_ref_time(2_938_681).saturating_mul(r.into()))
+ // Standard Error: 1_642
+ .saturating_add(Weight::from_ref_time(2_924_090).saturating_mul(r.into()))
}
/// The range of component `p` is `[0, 128]`.
fn instr_call_indirect_per_param(p: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 4_809 nanoseconds.
- Weight::from_ref_time(6_763_286)
+ // Minimum execution time: 4_670 nanoseconds.
+ Weight::from_ref_time(5_556_246)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 3_994
- .saturating_add(Weight::from_ref_time(217_632).saturating_mul(p.into()))
+ // Standard Error: 1_491
+ .saturating_add(Weight::from_ref_time(228_965).saturating_mul(p.into()))
}
/// The range of component `l` is `[0, 1024]`.
fn instr_call_per_local(l: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 3_138 nanoseconds.
- Weight::from_ref_time(3_894_816)
+ // Minimum execution time: 3_099 nanoseconds.
+ Weight::from_ref_time(3_896_177)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 131
- .saturating_add(Weight::from_ref_time(91_699).saturating_mul(l.into()))
+ // Standard Error: 99
+ .saturating_add(Weight::from_ref_time(91_304).saturating_mul(l.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_local_get(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_959 nanoseconds.
- Weight::from_ref_time(3_271_550)
+ // Minimum execution time: 3_042 nanoseconds.
+ Weight::from_ref_time(3_334_621)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 223
- .saturating_add(Weight::from_ref_time(460_056).saturating_mul(r.into()))
+ // Standard Error: 793
+ .saturating_add(Weight::from_ref_time(459_346).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_local_set(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_970 nanoseconds.
- Weight::from_ref_time(3_216_157)
+ // Minimum execution time: 2_968 nanoseconds.
+ Weight::from_ref_time(3_235_286)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 413
- .saturating_add(Weight::from_ref_time(485_842).saturating_mul(r.into()))
+ // Standard Error: 427
+ .saturating_add(Weight::from_ref_time(485_454).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_local_tee(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_980 nanoseconds.
- Weight::from_ref_time(3_323_878)
+ // Minimum execution time: 3_012 nanoseconds.
+ Weight::from_ref_time(3_303_555)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_652
- .saturating_add(Weight::from_ref_time(660_257).saturating_mul(r.into()))
+ // Standard Error: 371
+ .saturating_add(Weight::from_ref_time(657_811).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_global_get(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 917 nanoseconds.
- Weight::from_ref_time(1_445_816)
+ // Minimum execution time: 865 nanoseconds.
+ Weight::from_ref_time(1_249_987)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 5_642
- .saturating_add(Weight::from_ref_time(894_521).saturating_mul(r.into()))
+ // Standard Error: 417
+ .saturating_add(Weight::from_ref_time(896_704).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_global_set(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 965 nanoseconds.
- Weight::from_ref_time(1_373_722)
+ // Minimum execution time: 866 nanoseconds.
+ Weight::from_ref_time(1_216_218)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 1_157
- .saturating_add(Weight::from_ref_time(917_643).saturating_mul(r.into()))
+ // Standard Error: 503
+ .saturating_add(Weight::from_ref_time(919_719).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_memory_current(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 982 nanoseconds.
- Weight::from_ref_time(1_240_280)
+ // Minimum execution time: 921 nanoseconds.
+ Weight::from_ref_time(1_228_408)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 308
- .saturating_add(Weight::from_ref_time(817_972).saturating_mul(r.into()))
+ // Standard Error: 309
+ .saturating_add(Weight::from_ref_time(813_007).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 1]`.
fn instr_memory_grow(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 858 nanoseconds.
- Weight::from_ref_time(962_183)
+ // Minimum execution time: 820 nanoseconds.
+ Weight::from_ref_time(914_830)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 6_701
- .saturating_add(Weight::from_ref_time(239_704_216).saturating_mul(r.into()))
+ // Standard Error: 6_018
+ .saturating_add(Weight::from_ref_time(237_062_769).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64clz(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 807 nanoseconds.
- Weight::from_ref_time(1_132_872)
+ // Minimum execution time: 812 nanoseconds.
+ Weight::from_ref_time(1_554_406)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 303
- .saturating_add(Weight::from_ref_time(633_832).saturating_mul(r.into()))
+ // Standard Error: 9_979
+ .saturating_add(Weight::from_ref_time(625_434).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ctz(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 823 nanoseconds.
- Weight::from_ref_time(1_267_518)
+ // Minimum execution time: 798 nanoseconds.
+ Weight::from_ref_time(1_095_113)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 483
- .saturating_add(Weight::from_ref_time(632_620).saturating_mul(r.into()))
+ // Standard Error: 243
+ .saturating_add(Weight::from_ref_time(634_204).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64popcnt(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 857 nanoseconds.
- Weight::from_ref_time(1_105_214)
+ // Minimum execution time: 792 nanoseconds.
+ Weight::from_ref_time(1_109_845)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 285
- .saturating_add(Weight::from_ref_time(635_039).saturating_mul(r.into()))
+ // Standard Error: 14_944
+ .saturating_add(Weight::from_ref_time(658_834).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64eqz(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 821 nanoseconds.
- Weight::from_ref_time(750_223)
+ // Minimum execution time: 815 nanoseconds.
+ Weight::from_ref_time(1_068_916)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 15_923
- .saturating_add(Weight::from_ref_time(686_322).saturating_mul(r.into()))
+ // Standard Error: 327
+ .saturating_add(Weight::from_ref_time(652_897).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64extendsi32(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 797 nanoseconds.
- Weight::from_ref_time(1_145_072)
+ // Minimum execution time: 798 nanoseconds.
+ Weight::from_ref_time(1_069_745)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 311
- .saturating_add(Weight::from_ref_time(618_147).saturating_mul(r.into()))
+ // Standard Error: 306
+ .saturating_add(Weight::from_ref_time(618_481).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64extendui32(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 803 nanoseconds.
- Weight::from_ref_time(1_139_498)
+ // Minimum execution time: 799 nanoseconds.
+ Weight::from_ref_time(1_398_001)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 284
- .saturating_add(Weight::from_ref_time(617_393).saturating_mul(r.into()))
+ // Standard Error: 6_234
+ .saturating_add(Weight::from_ref_time(611_399).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i32wrapi64(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 814 nanoseconds.
- Weight::from_ref_time(1_099_405)
+ // Minimum execution time: 811 nanoseconds.
+ Weight::from_ref_time(1_098_083)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 663
- .saturating_add(Weight::from_ref_time(618_565).saturating_mul(r.into()))
+ // Standard Error: 297
+ .saturating_add(Weight::from_ref_time(617_692).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64eq(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 819 nanoseconds.
- Weight::from_ref_time(1_199_220)
+ // Minimum execution time: 815 nanoseconds.
+ Weight::from_ref_time(1_046_922)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 485
- .saturating_add(Weight::from_ref_time(906_878).saturating_mul(r.into()))
+ // Standard Error: 335
+ .saturating_add(Weight::from_ref_time(909_196).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ne(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 822 nanoseconds.
- Weight::from_ref_time(274_212)
+ // Minimum execution time: 805 nanoseconds.
+ Weight::from_ref_time(1_093_667)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 29_294
- .saturating_add(Weight::from_ref_time(971_608).saturating_mul(r.into()))
+ // Standard Error: 233
+ .saturating_add(Weight::from_ref_time(907_378).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64lts(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 796 nanoseconds.
- Weight::from_ref_time(1_396_586)
+ // Minimum execution time: 805 nanoseconds.
+ Weight::from_ref_time(1_290_591)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 7_205
- .saturating_add(Weight::from_ref_time(903_202).saturating_mul(r.into()))
+ // Standard Error: 3_201
+ .saturating_add(Weight::from_ref_time(902_006).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ltu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 833 nanoseconds.
- Weight::from_ref_time(1_115_115)
+ // Minimum execution time: 783 nanoseconds.
+ Weight::from_ref_time(1_159_977)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 310
- .saturating_add(Weight::from_ref_time(908_195).saturating_mul(r.into()))
+ // Standard Error: 2_310
+ .saturating_add(Weight::from_ref_time(906_489).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64gts(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 854 nanoseconds.
- Weight::from_ref_time(1_170_419)
+ // Minimum execution time: 790 nanoseconds.
+ Weight::from_ref_time(1_109_719)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 298
- .saturating_add(Weight::from_ref_time(907_171).saturating_mul(r.into()))
+ // Standard Error: 261
+ .saturating_add(Weight::from_ref_time(906_614).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64gtu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 822 nanoseconds.
- Weight::from_ref_time(1_186_349)
+ // Minimum execution time: 776 nanoseconds.
+ Weight::from_ref_time(1_076_567)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 302
- .saturating_add(Weight::from_ref_time(917_857).saturating_mul(r.into()))
+ // Standard Error: 348
+ .saturating_add(Weight::from_ref_time(919_374).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64les(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 807 nanoseconds.
- Weight::from_ref_time(1_127_093)
+ // Minimum execution time: 780 nanoseconds.
+ Weight::from_ref_time(1_069_663)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 1_891
- .saturating_add(Weight::from_ref_time(910_738).saturating_mul(r.into()))
+ // Standard Error: 265
+ .saturating_add(Weight::from_ref_time(908_037).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64leu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 819 nanoseconds.
- Weight::from_ref_time(1_143_022)
+ // Minimum execution time: 832 nanoseconds.
+ Weight::from_ref_time(930_920)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 309
- .saturating_add(Weight::from_ref_time(919_047).saturating_mul(r.into()))
+ // Standard Error: 2_170
+ .saturating_add(Weight::from_ref_time(929_811).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ges(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 788 nanoseconds.
- Weight::from_ref_time(1_116_914)
+ // Minimum execution time: 787 nanoseconds.
+ Weight::from_ref_time(1_087_325)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 643
- .saturating_add(Weight::from_ref_time(911_159).saturating_mul(r.into()))
+ // Standard Error: 315
+ .saturating_add(Weight::from_ref_time(908_321).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64geu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 791 nanoseconds.
- Weight::from_ref_time(1_123_747)
+ // Minimum execution time: 798 nanoseconds.
+ Weight::from_ref_time(1_029_132)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 583
- .saturating_add(Weight::from_ref_time(910_242).saturating_mul(r.into()))
+ // Standard Error: 2_095
+ .saturating_add(Weight::from_ref_time(913_553).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64add(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 787 nanoseconds.
- Weight::from_ref_time(1_109_471)
+ // Minimum execution time: 791 nanoseconds.
+ Weight::from_ref_time(1_086_314)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 305
- .saturating_add(Weight::from_ref_time(897_608).saturating_mul(r.into()))
+ // Standard Error: 197
+ .saturating_add(Weight::from_ref_time(896_392).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64sub(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 821 nanoseconds.
- Weight::from_ref_time(1_098_631)
+ // Minimum execution time: 793 nanoseconds.
+ Weight::from_ref_time(1_078_172)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 523
- .saturating_add(Weight::from_ref_time(887_814).saturating_mul(r.into()))
+ // Standard Error: 404
+ .saturating_add(Weight::from_ref_time(886_329).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64mul(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 794 nanoseconds.
- Weight::from_ref_time(1_166_332)
+ // Minimum execution time: 799 nanoseconds.
+ Weight::from_ref_time(1_095_010)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 384
- .saturating_add(Weight::from_ref_time(885_584).saturating_mul(r.into()))
+ // Standard Error: 431
+ .saturating_add(Weight::from_ref_time(886_513).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64divs(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 822 nanoseconds.
- Weight::from_ref_time(1_155_826)
+ // Minimum execution time: 810 nanoseconds.
+ Weight::from_ref_time(1_114_325)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 521
- .saturating_add(Weight::from_ref_time(1_520_958).saturating_mul(r.into()))
+ // Standard Error: 452
+ .saturating_add(Weight::from_ref_time(1_521_849).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64divu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 881 nanoseconds.
- Weight::from_ref_time(1_158_125)
+ // Minimum execution time: 784 nanoseconds.
+ Weight::from_ref_time(1_123_153)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 624
- .saturating_add(Weight::from_ref_time(1_458_378).saturating_mul(r.into()))
+ // Standard Error: 475
+ .saturating_add(Weight::from_ref_time(1_457_746).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64rems(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 827 nanoseconds.
- Weight::from_ref_time(1_209_535)
+ // Minimum execution time: 809 nanoseconds.
+ Weight::from_ref_time(1_145_906)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 399
- .saturating_add(Weight::from_ref_time(1_547_640).saturating_mul(r.into()))
+ // Standard Error: 718
+ .saturating_add(Weight::from_ref_time(1_549_964).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64remu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 801 nanoseconds.
- Weight::from_ref_time(1_313_872)
+ // Minimum execution time: 803 nanoseconds.
+ Weight::from_ref_time(1_110_328)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_175
- .saturating_add(Weight::from_ref_time(1_449_416).saturating_mul(r.into()))
+ // Standard Error: 627
+ .saturating_add(Weight::from_ref_time(1_453_013).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64and(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 827 nanoseconds.
- Weight::from_ref_time(1_093_874)
+ // Minimum execution time: 786 nanoseconds.
+ Weight::from_ref_time(1_108_792)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 708
- .saturating_add(Weight::from_ref_time(901_450).saturating_mul(r.into()))
+ // Standard Error: 286
+ .saturating_add(Weight::from_ref_time(897_035).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64or(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 824 nanoseconds.
- Weight::from_ref_time(1_164_076)
+ // Minimum execution time: 787 nanoseconds.
+ Weight::from_ref_time(830_000)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 623
- .saturating_add(Weight::from_ref_time(897_579).saturating_mul(r.into()))
+ // Standard Error: 15_995
+ .saturating_add(Weight::from_ref_time(963_344).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64xor(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 789 nanoseconds.
- Weight::from_ref_time(1_113_915)
+ // Minimum execution time: 773 nanoseconds.
+ Weight::from_ref_time(1_082_459)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 390
- .saturating_add(Weight::from_ref_time(897_354).saturating_mul(r.into()))
+ // Standard Error: 330
+ .saturating_add(Weight::from_ref_time(897_077).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64shl(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 811 nanoseconds.
- Weight::from_ref_time(1_117_366)
+ // Minimum execution time: 810 nanoseconds.
+ Weight::from_ref_time(1_325_815)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 437
- .saturating_add(Weight::from_ref_time(903_759).saturating_mul(r.into()))
+ // Standard Error: 3_352
+ .saturating_add(Weight::from_ref_time(899_555).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64shrs(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 846 nanoseconds.
- Weight::from_ref_time(1_103_954)
+ // Minimum execution time: 808 nanoseconds.
+ Weight::from_ref_time(1_085_903)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 414
- .saturating_add(Weight::from_ref_time(903_429).saturating_mul(r.into()))
+ // Standard Error: 430
+ .saturating_add(Weight::from_ref_time(903_249).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64shru(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 803 nanoseconds.
- Weight::from_ref_time(1_124_328)
+ // Minimum execution time: 792 nanoseconds.
+ Weight::from_ref_time(1_091_261)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 410
- .saturating_add(Weight::from_ref_time(903_216).saturating_mul(r.into()))
+ // Standard Error: 312
+ .saturating_add(Weight::from_ref_time(902_245).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64rotl(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 810 nanoseconds.
- Weight::from_ref_time(1_131_433)
+ // Minimum execution time: 807 nanoseconds.
+ Weight::from_ref_time(1_121_052)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 402
- .saturating_add(Weight::from_ref_time(903_381).saturating_mul(r.into()))
+ // Standard Error: 506
+ .saturating_add(Weight::from_ref_time(902_772).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64rotr(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 807 nanoseconds.
- Weight::from_ref_time(1_144_933)
+ // Minimum execution time: 823 nanoseconds.
+ Weight::from_ref_time(1_317_597)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 373
- .saturating_add(Weight::from_ref_time(902_918).saturating_mul(r.into()))
+ // Standard Error: 6_219
+ .saturating_add(Weight::from_ref_time(896_692).saturating_mul(r.into()))
}
}
@@ -2274,8 +2276,8 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `109`
// Estimated: `604`
- // Minimum execution time: 2_507 nanoseconds.
- Weight::from_ref_time(2_650_000)
+ // Minimum execution time: 2_591 nanoseconds.
+ Weight::from_ref_time(2_817_000)
.saturating_add(Weight::from_proof_size(604))
.saturating_add(RocksDbWeight::get().reads(1_u64))
}
@@ -2286,11 +2288,11 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `481 + k * (69 ±0)`
// Estimated: `471 + k * (70 ±0)`
- // Minimum execution time: 9_953 nanoseconds.
- Weight::from_ref_time(6_467_352)
+ // Minimum execution time: 10_190 nanoseconds.
+ Weight::from_ref_time(6_642_117)
.saturating_add(Weight::from_proof_size(471))
- // Standard Error: 1_074
- .saturating_add(Weight::from_ref_time(943_946).saturating_mul(k.into()))
+ // Standard Error: 992
+ .saturating_add(Weight::from_ref_time(919_828).saturating_mul(k.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into())))
@@ -2303,11 +2305,11 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `281 + q * (33 ±0)`
// Estimated: `763 + q * (33 ±0)`
- // Minimum execution time: 2_545 nanoseconds.
- Weight::from_ref_time(10_080_106)
+ // Minimum execution time: 2_598 nanoseconds.
+ Weight::from_ref_time(10_288_252)
.saturating_add(Weight::from_proof_size(763))
- // Standard Error: 2_929
- .saturating_add(Weight::from_ref_time(1_078_265).saturating_mul(q.into()))
+ // Standard Error: 2_886
+ .saturating_add(Weight::from_ref_time(1_092_420).saturating_mul(q.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
.saturating_add(Weight::from_proof_size(33).saturating_mul(q.into()))
@@ -2321,17 +2323,17 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `270 + c * (1 ±0)`
// Estimated: `3025 + c * (2 ±0)`
- // Minimum execution time: 34_613 nanoseconds.
- Weight::from_ref_time(27_355_774)
+ // Minimum execution time: 34_338 nanoseconds.
+ Weight::from_ref_time(32_159_677)
.saturating_add(Weight::from_proof_size(3025))
- // Standard Error: 81
- .saturating_add(Weight::from_ref_time(51_954).saturating_mul(c.into()))
+ // Standard Error: 53
+ .saturating_add(Weight::from_ref_time(51_034).saturating_mul(c.into()))
.saturating_add(RocksDbWeight::get().reads(1_u64))
.saturating_add(RocksDbWeight::get().writes(1_u64))
.saturating_add(Weight::from_proof_size(2).saturating_mul(c.into()))
}
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2343,13 +2345,13 @@ impl WeightInfo for () {
/// The range of component `c` is `[0, 125952]`.
fn call_with_code_per_byte(c: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `771`
- // Estimated: `16780 + c * (5 ±0)`
- // Minimum execution time: 386_104 nanoseconds.
- Weight::from_ref_time(396_718_823)
- .saturating_add(Weight::from_proof_size(16780))
+ // Measured: `803`
+ // Estimated: `16930 + c * (5 ±0)`
+ // Minimum execution time: 385_587 nanoseconds.
+ Weight::from_ref_time(395_545_811)
+ .saturating_add(Weight::from_proof_size(16930))
// Standard Error: 27
- .saturating_add(Weight::from_ref_time(31_370).saturating_mul(c.into()))
+ .saturating_add(Weight::from_ref_time(31_342).saturating_mul(c.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
.saturating_add(Weight::from_proof_size(5).saturating_mul(c.into()))
@@ -2359,10 +2361,10 @@ impl WeightInfo for () {
/// Storage: Contracts Nonce (r:1 w:1)
/// Proof: Contracts Nonce (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
/// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
- /// Storage: System Account (r:1 w:1)
+ /// Storage: System Account (r:2 w:2)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: System EventTopics (r:3 w:3)
/// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured)
@@ -2375,29 +2377,29 @@ impl WeightInfo for () {
/// The range of component `s` is `[0, 1048576]`.
fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `257`
- // Estimated: `17752`
- // Minimum execution time: 3_786_500 nanoseconds.
- Weight::from_ref_time(672_511_565)
- .saturating_add(Weight::from_proof_size(17752))
- // Standard Error: 281
- .saturating_add(Weight::from_ref_time(94_538).saturating_mul(c.into()))
+ // Measured: `270`
+ // Estimated: `20267`
+ // Minimum execution time: 3_799_742 nanoseconds.
+ Weight::from_ref_time(670_115_588)
+ .saturating_add(Weight::from_proof_size(20267))
+ // Standard Error: 287
+ .saturating_add(Weight::from_ref_time(93_885).saturating_mul(c.into()))
// Standard Error: 16
- .saturating_add(Weight::from_ref_time(1_364).saturating_mul(i.into()))
+ .saturating_add(Weight::from_ref_time(1_367).saturating_mul(i.into()))
// Standard Error: 16
- .saturating_add(Weight::from_ref_time(1_768).saturating_mul(s.into()))
- .saturating_add(RocksDbWeight::get().reads(8_u64))
- .saturating_add(RocksDbWeight::get().writes(9_u64))
+ .saturating_add(Weight::from_ref_time(1_781).saturating_mul(s.into()))
+ .saturating_add(RocksDbWeight::get().reads(9_u64))
+ .saturating_add(RocksDbWeight::get().writes(10_u64))
}
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Contracts Nonce (r:1 w:1)
/// Proof: Contracts Nonce (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
/// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: Measured)
- /// Storage: System Account (r:1 w:1)
+ /// Storage: System Account (r:2 w:2)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts OwnerInfoOf (r:1 w:1)
/// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured)
@@ -2407,20 +2409,20 @@ impl WeightInfo for () {
/// The range of component `s` is `[0, 1048576]`.
fn instantiate(i: u32, s: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `533`
- // Estimated: `19543`
- // Minimum execution time: 1_927_365 nanoseconds.
- Weight::from_ref_time(189_843_928)
- .saturating_add(Weight::from_proof_size(19543))
+ // Measured: `546`
+ // Estimated: `22039`
+ // Minimum execution time: 1_949_008 nanoseconds.
+ Weight::from_ref_time(214_033_418)
+ .saturating_add(Weight::from_proof_size(22039))
// Standard Error: 8
- .saturating_add(Weight::from_ref_time(1_677).saturating_mul(i.into()))
+ .saturating_add(Weight::from_ref_time(1_666).saturating_mul(i.into()))
// Standard Error: 8
- .saturating_add(Weight::from_ref_time(1_803).saturating_mul(s.into()))
- .saturating_add(RocksDbWeight::get().reads(8_u64))
- .saturating_add(RocksDbWeight::get().writes(6_u64))
+ .saturating_add(Weight::from_ref_time(1_801).saturating_mul(s.into()))
+ .saturating_add(RocksDbWeight::get().reads(9_u64))
+ .saturating_add(RocksDbWeight::get().writes(7_u64))
}
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2431,11 +2433,11 @@ impl WeightInfo for () {
/// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured)
fn call() -> Weight {
// Proof Size summary in bytes:
- // Measured: `823`
- // Estimated: `16985`
- // Minimum execution time: 146_354 nanoseconds.
- Weight::from_ref_time(147_693_000)
- .saturating_add(Weight::from_proof_size(16985))
+ // Measured: `855`
+ // Estimated: `17145`
+ // Minimum execution time: 146_654 nanoseconds.
+ Weight::from_ref_time(147_528_000)
+ .saturating_add(Weight::from_proof_size(17145))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
@@ -2452,11 +2454,11 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `109`
// Estimated: `5386`
- // Minimum execution time: 388_107 nanoseconds.
- Weight::from_ref_time(383_172_702)
+ // Minimum execution time: 387_889 nanoseconds.
+ Weight::from_ref_time(391_379_335)
.saturating_add(Weight::from_proof_size(5386))
- // Standard Error: 73
- .saturating_add(Weight::from_ref_time(95_037).saturating_mul(c.into()))
+ // Standard Error: 89
+ .saturating_add(Weight::from_ref_time(94_810).saturating_mul(c.into()))
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
@@ -2472,32 +2474,32 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `287`
// Estimated: `6098`
- // Minimum execution time: 26_278 nanoseconds.
- Weight::from_ref_time(26_682_000)
+ // Minimum execution time: 26_014 nanoseconds.
+ Weight::from_ref_time(26_510_000)
.saturating_add(Weight::from_proof_size(6098))
.saturating_add(RocksDbWeight::get().reads(2_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
}
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts OwnerInfoOf (r:2 w:2)
/// Proof: Contracts OwnerInfoOf (max_values: None, max_size: Some(88), added: 2563, mode: Measured)
/// Storage: System EventTopics (r:3 w:3)
/// Proof Skipped: System EventTopics (max_values: None, max_size: None, mode: Measured)
fn set_code() -> Weight {
// Proof Size summary in bytes:
- // Measured: `634`
- // Estimated: `16752`
- // Minimum execution time: 30_223 nanoseconds.
- Weight::from_ref_time(30_737_000)
- .saturating_add(Weight::from_proof_size(16752))
+ // Measured: `666`
+ // Estimated: `16848`
+ // Minimum execution time: 30_177 nanoseconds.
+ Weight::from_ref_time(30_639_000)
+ .saturating_add(Weight::from_proof_size(16848))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(6_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2507,13 +2509,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_caller(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `845 + r * (480 ±0)`
- // Estimated: `17120 + r * (2400 ±0)`
- // Minimum execution time: 374_780 nanoseconds.
- Weight::from_ref_time(379_468_453)
- .saturating_add(Weight::from_proof_size(17120))
- // Standard Error: 45_809
- .saturating_add(Weight::from_ref_time(17_553_577).saturating_mul(r.into()))
+ // Measured: `877 + r * (480 ±0)`
+ // Estimated: `17295 + r * (2400 ±0)`
+ // Minimum execution time: 373_786 nanoseconds.
+ Weight::from_ref_time(377_332_691)
+ .saturating_add(Weight::from_proof_size(17295))
+ // Standard Error: 51_211
+ .saturating_add(Weight::from_ref_time(17_715_615).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2521,7 +2523,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2531,22 +2533,22 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_is_contract(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `882 + r * (19218 ±0)`
- // Estimated: `17110 + r * (294100 ±0)`
- // Minimum execution time: 374_399 nanoseconds.
- Weight::from_ref_time(228_569_211)
- .saturating_add(Weight::from_proof_size(17110))
- // Standard Error: 492_562
- .saturating_add(Weight::from_ref_time(251_682_897).saturating_mul(r.into()))
+ // Measured: `917 + r * (21778 ±0)`
+ // Estimated: `17295 + r * (306895 ±0)`
+ // Minimum execution time: 374_009 nanoseconds.
+ Weight::from_ref_time(238_991_986)
+ .saturating_add(Weight::from_proof_size(17295))
+ // Standard Error: 464_711
+ .saturating_add(Weight::from_ref_time(249_099_538).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(294100).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(306895).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2556,22 +2558,22 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_code_hash(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `889 + r * (19539 ±0)`
- // Estimated: `17170 + r * (295700 ±0)`
- // Minimum execution time: 375_980 nanoseconds.
- Weight::from_ref_time(232_604_331)
- .saturating_add(Weight::from_proof_size(17170))
- // Standard Error: 491_912
- .saturating_add(Weight::from_ref_time(299_479_335).saturating_mul(r.into()))
+ // Measured: `921 + r * (22099 ±0)`
+ // Estimated: `17340 + r * (308500 ±0)`
+ // Minimum execution time: 375_058 nanoseconds.
+ Weight::from_ref_time(238_765_068)
+ .saturating_add(Weight::from_proof_size(17340))
+ // Standard Error: 662_617
+ .saturating_add(Weight::from_ref_time(302_175_089).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(295700).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(308500).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2581,13 +2583,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_own_code_hash(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `852 + r * (480 ±0)`
- // Estimated: `17155 + r * (2400 ±0)`
- // Minimum execution time: 375_075 nanoseconds.
- Weight::from_ref_time(381_217_372)
- .saturating_add(Weight::from_proof_size(17155))
- // Standard Error: 63_950
- .saturating_add(Weight::from_ref_time(21_872_316).saturating_mul(r.into()))
+ // Measured: `884 + r * (480 ±0)`
+ // Estimated: `17330 + r * (2400 ±0)`
+ // Minimum execution time: 374_747 nanoseconds.
+ Weight::from_ref_time(376_482_380)
+ .saturating_add(Weight::from_proof_size(17330))
+ // Standard Error: 61_919
+ .saturating_add(Weight::from_ref_time(22_376_795).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2595,7 +2597,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2605,13 +2607,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_caller_is_origin(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842 + r * (240 ±0)`
- // Estimated: `17080 + r * (1200 ±0)`
- // Minimum execution time: 373_260 nanoseconds.
- Weight::from_ref_time(377_987_666)
- .saturating_add(Weight::from_proof_size(17080))
- // Standard Error: 35_603
- .saturating_add(Weight::from_ref_time(11_274_165).saturating_mul(r.into()))
+ // Measured: `874 + r * (240 ±0)`
+ // Estimated: `17265 + r * (1200 ±0)`
+ // Minimum execution time: 372_287 nanoseconds.
+ Weight::from_ref_time(376_250_858)
+ .saturating_add(Weight::from_proof_size(17265))
+ // Standard Error: 40_119
+ .saturating_add(Weight::from_ref_time(11_359_647).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into()))
@@ -2619,7 +2621,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2629,13 +2631,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_address(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `846 + r * (480 ±0)`
- // Estimated: `17100 + r * (2400 ±0)`
- // Minimum execution time: 374_605 nanoseconds.
- Weight::from_ref_time(379_395_443)
- .saturating_add(Weight::from_proof_size(17100))
- // Standard Error: 49_646
- .saturating_add(Weight::from_ref_time(17_487_585).saturating_mul(r.into()))
+ // Measured: `878 + r * (480 ±0)`
+ // Estimated: `17260 + r * (2400 ±0)`
+ // Minimum execution time: 374_445 nanoseconds.
+ Weight::from_ref_time(377_243_521)
+ .saturating_add(Weight::from_proof_size(17260))
+ // Standard Error: 53_032
+ .saturating_add(Weight::from_ref_time(17_684_246).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2643,7 +2645,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2653,21 +2655,21 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_gas_left(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `847 + r * (480 ±0)`
- // Estimated: `17105 + r * (2400 ±0)`
- // Minimum execution time: 374_620 nanoseconds.
- Weight::from_ref_time(379_623_792)
- .saturating_add(Weight::from_proof_size(17105))
- // Standard Error: 49_990
- .saturating_add(Weight::from_ref_time(17_226_706).saturating_mul(r.into()))
+ // Measured: `879 + r * (480 ±0)`
+ // Estimated: `17250 + r * (2405 ±0)`
+ // Minimum execution time: 374_029 nanoseconds.
+ Weight::from_ref_time(380_415_186)
+ .saturating_add(Weight::from_proof_size(17250))
+ // Standard Error: 60_562
+ .saturating_add(Weight::from_ref_time(17_152_599).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(2405).saturating_mul(r.into()))
}
/// Storage: System Account (r:2 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2677,13 +2679,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_balance(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1017 + r * (480 ±0)`
- // Estimated: `19673 + r * (2456 ±4)`
- // Minimum execution time: 374_002 nanoseconds.
- Weight::from_ref_time(384_615_649)
- .saturating_add(Weight::from_proof_size(19673))
- // Standard Error: 85_633
- .saturating_add(Weight::from_ref_time(95_227_118).saturating_mul(r.into()))
+ // Measured: `1049 + r * (480 ±0)`
+ // Estimated: `19849 + r * (2456 ±0)`
+ // Minimum execution time: 373_999 nanoseconds.
+ Weight::from_ref_time(381_757_033)
+ .saturating_add(Weight::from_proof_size(19849))
+ // Standard Error: 97_983
+ .saturating_add(Weight::from_ref_time(98_290_984).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2456).saturating_mul(r.into()))
@@ -2691,7 +2693,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2701,13 +2703,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_value_transferred(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `856 + r * (480 ±0)`
- // Estimated: `17200 + r * (2400 ±0)`
- // Minimum execution time: 375_307 nanoseconds.
- Weight::from_ref_time(378_389_705)
- .saturating_add(Weight::from_proof_size(17200))
- // Standard Error: 42_265
- .saturating_add(Weight::from_ref_time(17_316_680).saturating_mul(r.into()))
+ // Measured: `888 + r * (480 ±0)`
+ // Estimated: `17360 + r * (2400 ±0)`
+ // Minimum execution time: 374_197 nanoseconds.
+ Weight::from_ref_time(377_755_896)
+ .saturating_add(Weight::from_proof_size(17360))
+ // Standard Error: 60_542
+ .saturating_add(Weight::from_ref_time(17_442_065).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2715,7 +2717,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2725,13 +2727,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_minimum_balance(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `854 + r * (480 ±0)`
- // Estimated: `17140 + r * (2400 ±0)`
- // Minimum execution time: 374_878 nanoseconds.
- Weight::from_ref_time(379_364_066)
- .saturating_add(Weight::from_proof_size(17140))
- // Standard Error: 49_158
- .saturating_add(Weight::from_ref_time(17_111_145).saturating_mul(r.into()))
+ // Measured: `886 + r * (480 ±0)`
+ // Estimated: `17290 + r * (2400 ±0)`
+ // Minimum execution time: 373_888 nanoseconds.
+ Weight::from_ref_time(377_825_771)
+ .saturating_add(Weight::from_proof_size(17290))
+ // Standard Error: 38_026
+ .saturating_add(Weight::from_ref_time(17_147_903).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2739,7 +2741,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2749,13 +2751,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_block_number(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `851 + r * (480 ±0)`
- // Estimated: `17125 + r * (2400 ±0)`
- // Minimum execution time: 374_981 nanoseconds.
- Weight::from_ref_time(381_539_022)
- .saturating_add(Weight::from_proof_size(17125))
- // Standard Error: 61_419
- .saturating_add(Weight::from_ref_time(17_062_381).saturating_mul(r.into()))
+ // Measured: `883 + r * (480 ±0)`
+ // Estimated: `17315 + r * (2400 ±0)`
+ // Minimum execution time: 373_904 nanoseconds.
+ Weight::from_ref_time(378_652_372)
+ .saturating_add(Weight::from_proof_size(17315))
+ // Standard Error: 43_833
+ .saturating_add(Weight::from_ref_time(16_936_781).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2763,7 +2765,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2773,13 +2775,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_now(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842 + r * (480 ±0)`
- // Estimated: `17100 + r * (2400 ±0)`
- // Minimum execution time: 374_798 nanoseconds.
- Weight::from_ref_time(372_659_915)
- .saturating_add(Weight::from_proof_size(17100))
- // Standard Error: 151_499
- .saturating_add(Weight::from_ref_time(18_192_683).saturating_mul(r.into()))
+ // Measured: `874 + r * (480 ±0)`
+ // Estimated: `17245 + r * (2400 ±0)`
+ // Minimum execution time: 373_473 nanoseconds.
+ Weight::from_ref_time(376_386_312)
+ .saturating_add(Weight::from_proof_size(17245))
+ // Standard Error: 46_945
+ .saturating_add(Weight::from_ref_time(17_336_462).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2787,7 +2789,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2799,13 +2801,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_weight_to_fee(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `919 + r * (800 ±0)`
- // Estimated: `18835 + r * (4805 ±0)`
- // Minimum execution time: 374_841 nanoseconds.
- Weight::from_ref_time(385_475_889)
- .saturating_add(Weight::from_proof_size(18835))
- // Standard Error: 106_207
- .saturating_add(Weight::from_ref_time(88_099_987).saturating_mul(r.into()))
+ // Measured: `951 + r * (800 ±0)`
+ // Estimated: `19046 + r * (4805 ±0)`
+ // Minimum execution time: 373_661 nanoseconds.
+ Weight::from_ref_time(385_824_015)
+ .saturating_add(Weight::from_proof_size(19046))
+ // Standard Error: 75_964
+ .saturating_add(Weight::from_ref_time(88_530_074).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into()))
@@ -2813,7 +2815,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2823,13 +2825,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_gas(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `809 + r * (320 ±0)`
- // Estimated: `16955 + r * (1600 ±0)`
- // Minimum execution time: 134_436 nanoseconds.
- Weight::from_ref_time(137_789_498)
- .saturating_add(Weight::from_proof_size(16955))
- // Standard Error: 10_622
- .saturating_add(Weight::from_ref_time(8_144_024).saturating_mul(r.into()))
+ // Measured: `841 + r * (320 ±0)`
+ // Estimated: `17120 + r * (1600 ±0)`
+ // Minimum execution time: 133_849 nanoseconds.
+ Weight::from_ref_time(137_283_391)
+ .saturating_add(Weight::from_proof_size(17120))
+ // Standard Error: 13_312
+ .saturating_add(Weight::from_ref_time(8_055_328).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(1600).saturating_mul(r.into()))
@@ -2837,7 +2839,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2847,13 +2849,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_input(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `844 + r * (480 ±0)`
- // Estimated: `17085 + r * (2400 ±0)`
- // Minimum execution time: 374_480 nanoseconds.
- Weight::from_ref_time(379_723_392)
- .saturating_add(Weight::from_proof_size(17085))
- // Standard Error: 50_240
- .saturating_add(Weight::from_ref_time(15_358_041).saturating_mul(r.into()))
+ // Measured: `876 + r * (480 ±0)`
+ // Estimated: `17245 + r * (2400 ±0)`
+ // Minimum execution time: 373_468 nanoseconds.
+ Weight::from_ref_time(376_121_093)
+ .saturating_add(Weight::from_proof_size(17245))
+ // Standard Error: 61_857
+ .saturating_add(Weight::from_ref_time(15_868_414).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2400).saturating_mul(r.into()))
@@ -2861,7 +2863,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2871,20 +2873,20 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 1024]`.
fn seal_input_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1324`
- // Estimated: `19490`
- // Minimum execution time: 392_282 nanoseconds.
- Weight::from_ref_time(418_943_323)
- .saturating_add(Weight::from_proof_size(19490))
- // Standard Error: 4_673
- .saturating_add(Weight::from_ref_time(9_664_301).saturating_mul(n.into()))
+ // Measured: `1356`
+ // Estimated: `19650`
+ // Minimum execution time: 390_668 nanoseconds.
+ Weight::from_ref_time(419_608_449)
+ .saturating_add(Weight::from_proof_size(19650))
+ // Standard Error: 4_890
+ .saturating_add(Weight::from_ref_time(9_672_288).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2894,11 +2896,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_return(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `832 + r * (45 ±0)`
- // Estimated: `17030 + r * (225 ±0)`
- // Minimum execution time: 372_207 nanoseconds.
- Weight::from_ref_time(376_232_444)
- .saturating_add(Weight::from_proof_size(17030))
+ // Measured: `864 + r * (45 ±0)`
+ // Estimated: `17190 + r * (225 ±0)`
+ // Minimum execution time: 371_309 nanoseconds.
+ Weight::from_ref_time(373_625_402)
+ .saturating_add(Weight::from_proof_size(17190))
+ // Standard Error: 419_605
+ .saturating_add(Weight::from_ref_time(1_737_397).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(225).saturating_mul(r.into()))
@@ -2906,7 +2910,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2916,20 +2920,20 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 1024]`.
fn seal_return_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842`
- // Estimated: `17125`
- // Minimum execution time: 374_743 nanoseconds.
- Weight::from_ref_time(377_365_053)
- .saturating_add(Weight::from_proof_size(17125))
- // Standard Error: 1_073
- .saturating_add(Weight::from_ref_time(231_251).saturating_mul(n.into()))
+ // Measured: `874`
+ // Estimated: `17285`
+ // Minimum execution time: 374_094 nanoseconds.
+ Weight::from_ref_time(375_965_200)
+ .saturating_add(Weight::from_proof_size(17285))
+ // Standard Error: 1_127
+ .saturating_add(Weight::from_ref_time(232_645).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
- /// Storage: System Account (r:3 w:3)
+ /// Storage: System Account (r:4 w:4)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2943,23 +2947,23 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_terminate(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `874 + r * (280 ±0)`
- // Estimated: `19880 + r * (11465 ±0)`
- // Minimum execution time: 374_873 nanoseconds.
- Weight::from_ref_time(378_422_289)
- .saturating_add(Weight::from_proof_size(19880))
- // Standard Error: 979_734
- .saturating_add(Weight::from_ref_time(57_035_310).saturating_mul(r.into()))
+ // Measured: `906 + r * (452 ±0)`
+ // Estimated: `20242 + r * (15004 ±0)`
+ // Minimum execution time: 373_123 nanoseconds.
+ Weight::from_ref_time(374_924_634)
+ .saturating_add(Weight::from_proof_size(20242))
+ // Standard Error: 378_010
+ .saturating_add(Weight::from_ref_time(70_441_665).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
- .saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(r.into())))
+ .saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(RocksDbWeight::get().writes((6_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(11465).saturating_mul(r.into()))
+ .saturating_add(RocksDbWeight::get().writes((7_u64).saturating_mul(r.into())))
+ .saturating_add(Weight::from_proof_size(15004).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2971,13 +2975,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_random(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `889 + r * (800 ±0)`
- // Estimated: `18643 + r * (4805 ±0)`
- // Minimum execution time: 375_001 nanoseconds.
- Weight::from_ref_time(382_558_599)
- .saturating_add(Weight::from_proof_size(18643))
- // Standard Error: 94_918
- .saturating_add(Weight::from_ref_time(112_973_277).saturating_mul(r.into()))
+ // Measured: `921 + r * (800 ±0)`
+ // Estimated: `18835 + r * (4805 ±0)`
+ // Minimum execution time: 373_291 nanoseconds.
+ Weight::from_ref_time(385_684_344)
+ .saturating_add(Weight::from_proof_size(18835))
+ // Standard Error: 99_025
+ .saturating_add(Weight::from_ref_time(111_308_793).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(4805).saturating_mul(r.into()))
@@ -2985,7 +2989,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -2995,13 +2999,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_deposit_event(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `842 + r * (800 ±0)`
- // Estimated: `17075 + r * (4000 ±0)`
- // Minimum execution time: 372_547 nanoseconds.
- Weight::from_ref_time(383_278_916)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 128_339
- .saturating_add(Weight::from_ref_time(229_356_088).saturating_mul(r.into()))
+ // Measured: `874 + r * (800 ±0)`
+ // Estimated: `17250 + r * (4000 ±0)`
+ // Minimum execution time: 371_900 nanoseconds.
+ Weight::from_ref_time(384_166_626)
+ .saturating_add(Weight::from_proof_size(17250))
+ // Standard Error: 205_255
+ .saturating_add(Weight::from_ref_time(229_214_157).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(4000).saturating_mul(r.into()))
@@ -3009,7 +3013,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3020,15 +3024,15 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 16]`.
fn seal_deposit_event_per_topic_and_kb(t: u32, n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1778 + t * (2608 ±0) + n * (8 ±0)`
- // Estimated: `21675 + t * (211030 ±0) + n * (50 ±0)`
- // Minimum execution time: 1_290_432 nanoseconds.
- Weight::from_ref_time(595_859_216)
- .saturating_add(Weight::from_proof_size(21675))
- // Standard Error: 602_943
- .saturating_add(Weight::from_ref_time(178_128_149).saturating_mul(t.into()))
- // Standard Error: 165_597
- .saturating_add(Weight::from_ref_time(71_475_468).saturating_mul(n.into()))
+ // Measured: `1821 + t * (2608 ±0) + n * (7 ±0)`
+ // Estimated: `21870 + t * (211030 ±0) + n * (50 ±0)`
+ // Minimum execution time: 1_289_873 nanoseconds.
+ Weight::from_ref_time(581_702_206)
+ .saturating_add(Weight::from_proof_size(21870))
+ // Standard Error: 665_638
+ .saturating_add(Weight::from_ref_time(181_470_553).saturating_mul(t.into()))
+ // Standard Error: 182_816
+ .saturating_add(Weight::from_ref_time(71_635_250).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(t.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
@@ -3039,7 +3043,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3049,13 +3053,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_debug_message(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (560 ±0)`
- // Estimated: `17065 + r * (2800 ±0)`
- // Minimum execution time: 149_020 nanoseconds.
- Weight::from_ref_time(152_893_012)
- .saturating_add(Weight::from_proof_size(17065))
- // Standard Error: 31_804
- .saturating_add(Weight::from_ref_time(14_497_512).saturating_mul(r.into()))
+ // Measured: `873 + r * (560 ±0)`
+ // Estimated: `17240 + r * (2800 ±0)`
+ // Minimum execution time: 148_635 nanoseconds.
+ Weight::from_ref_time(154_095_712)
+ .saturating_add(Weight::from_proof_size(17240))
+ // Standard Error: 77_790
+ .saturating_add(Weight::from_ref_time(14_837_085).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(2800).saturating_mul(r.into()))
@@ -3063,7 +3067,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: MaxEncodedLen)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: MaxEncodedLen)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: MaxEncodedLen)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3073,13 +3077,13 @@ impl WeightInfo for () {
/// The range of component `i` is `[0, 1024]`.
fn seal_debug_message_per_kb(i: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `125792`
- // Estimated: `265059`
- // Minimum execution time: 502_589 nanoseconds.
- Weight::from_ref_time(506_695_307)
- .saturating_add(Weight::from_proof_size(265059))
- // Standard Error: 2_148
- .saturating_add(Weight::from_ref_time(814_647).saturating_mul(i.into()))
+ // Measured: `125824`
+ // Estimated: `265128`
+ // Minimum execution time: 501_014 nanoseconds.
+ Weight::from_ref_time(505_634_218)
+ .saturating_add(Weight::from_proof_size(265128))
+ // Standard Error: 2_441
+ .saturating_add(Weight::from_ref_time(819_257).saturating_mul(i.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
@@ -3088,85 +3092,85 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 10]`.
fn seal_set_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `883 + r * (23417 ±0)`
- // Estimated: `883 + r * (23417 ±0)`
- // Minimum execution time: 375_473 nanoseconds.
- Weight::from_ref_time(291_125_810)
- .saturating_add(Weight::from_proof_size(883))
- // Standard Error: 824_971
- .saturating_add(Weight::from_ref_time(477_999_695).saturating_mul(r.into()))
+ // Measured: `911 + r * (23420 ±0)`
+ // Estimated: `911 + r * (23418 ±0)`
+ // Minimum execution time: 375_301 nanoseconds.
+ Weight::from_ref_time(291_498_841)
+ .saturating_add(Weight::from_proof_size(911))
+ // Standard Error: 809_989
+ .saturating_add(Weight::from_ref_time(464_550_291).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(RocksDbWeight::get().writes((80_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(23417).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23418).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_set_storage_per_new_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `12583 + n * (11969 ±0)`
- // Estimated: `8500 + n * (12813 ±61)`
- // Minimum execution time: 515_962 nanoseconds.
- Weight::from_ref_time(697_904_030)
- .saturating_add(Weight::from_proof_size(8500))
- // Standard Error: 1_684_000
- .saturating_add(Weight::from_ref_time(98_411_710).saturating_mul(n.into()))
+ // Measured: `12672 + n * (11945 ±0)`
+ // Estimated: `8529 + n * (12814 ±61)`
+ // Minimum execution time: 506_318 nanoseconds.
+ Weight::from_ref_time(676_935_313)
+ .saturating_add(Weight::from_proof_size(8529))
+ // Standard Error: 1_589_291
+ .saturating_add(Weight::from_ref_time(97_839_399).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(52_u64))
.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(RocksDbWeight::get().writes(50_u64))
.saturating_add(RocksDbWeight::get().writes((7_u64).saturating_mul(n.into())))
- .saturating_add(Weight::from_proof_size(12813).saturating_mul(n.into()))
+ .saturating_add(Weight::from_proof_size(12814).saturating_mul(n.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_set_storage_per_old_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `15138 + n * (175775 ±0)`
- // Estimated: `9898 + n * (176855 ±74)`
- // Minimum execution time: 515_828 nanoseconds.
- Weight::from_ref_time(661_240_495)
- .saturating_add(Weight::from_proof_size(9898))
- // Standard Error: 1_338_661
- .saturating_add(Weight::from_ref_time(65_767_819).saturating_mul(n.into()))
+ // Measured: `15170 + n * (175775 ±0)`
+ // Estimated: `9914 + n * (176858 ±74)`
+ // Minimum execution time: 506_148 nanoseconds.
+ Weight::from_ref_time(648_278_778)
+ .saturating_add(Weight::from_proof_size(9914))
+ // Standard Error: 1_343_586
+ .saturating_add(Weight::from_ref_time(65_789_595).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(51_u64))
.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(RocksDbWeight::get().writes(49_u64))
.saturating_add(RocksDbWeight::get().writes((7_u64).saturating_mul(n.into())))
- .saturating_add(Weight::from_proof_size(176855).saturating_mul(n.into()))
+ .saturating_add(Weight::from_proof_size(176858).saturating_mul(n.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `r` is `[0, 10]`.
fn seal_clear_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `876 + r * (23098 ±0)`
- // Estimated: `881 + r * (23097 ±0)`
- // Minimum execution time: 375_528 nanoseconds.
- Weight::from_ref_time(296_453_612)
- .saturating_add(Weight::from_proof_size(881))
- // Standard Error: 809_232
- .saturating_add(Weight::from_ref_time(465_365_815).saturating_mul(r.into()))
+ // Measured: `903 + r * (23099 ±0)`
+ // Estimated: `908 + r * (23099 ±0)`
+ // Minimum execution time: 374_344 nanoseconds.
+ Weight::from_ref_time(293_272_061)
+ .saturating_add(Weight::from_proof_size(908))
+ // Standard Error: 810_412
+ .saturating_add(Weight::from_ref_time(453_315_956).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(RocksDbWeight::get().writes((80_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(23097).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_clear_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `14863 + n * (175768 ±0)`
- // Estimated: `9519 + n * (176867 ±75)`
- // Minimum execution time: 480_427 nanoseconds.
- Weight::from_ref_time(640_337_570)
- .saturating_add(Weight::from_proof_size(9519))
- // Standard Error: 1_497_141
- .saturating_add(Weight::from_ref_time(67_963_696).saturating_mul(n.into()))
+ // Measured: `14895 + n * (175768 ±0)`
+ // Estimated: `9551 + n * (176867 ±75)`
+ // Minimum execution time: 478_564 nanoseconds.
+ Weight::from_ref_time(630_839_142)
+ .saturating_add(Weight::from_proof_size(9551))
+ // Standard Error: 1_427_520
+ .saturating_add(Weight::from_ref_time(66_813_592).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(51_u64))
.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(RocksDbWeight::get().writes(48_u64))
@@ -3178,30 +3182,30 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 10]`.
fn seal_get_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `878 + r * (23740 ±0)`
- // Estimated: `880 + r * (23739 ±0)`
- // Minimum execution time: 375_725 nanoseconds.
- Weight::from_ref_time(307_839_394)
- .saturating_add(Weight::from_proof_size(880))
- // Standard Error: 710_694
- .saturating_add(Weight::from_ref_time(381_738_407).saturating_mul(r.into()))
+ // Measured: `896 + r * (23744 ±0)`
+ // Estimated: `909 + r * (23740 ±0)`
+ // Minimum execution time: 374_479 nanoseconds.
+ Weight::from_ref_time(311_839_315)
+ .saturating_add(Weight::from_proof_size(909))
+ // Standard Error: 666_553
+ .saturating_add(Weight::from_ref_time(371_213_042).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(23739).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23740).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_get_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `15469 + n * (175775 ±0)`
- // Estimated: `10010 + n * (176900 ±76)`
- // Minimum execution time: 461_871 nanoseconds.
- Weight::from_ref_time(605_755_493)
- .saturating_add(Weight::from_proof_size(10010))
- // Standard Error: 1_375_044
- .saturating_add(Weight::from_ref_time(161_332_330).saturating_mul(n.into()))
+ // Measured: `15501 + n * (175775 ±0)`
+ // Estimated: `10042 + n * (176900 ±76)`
+ // Minimum execution time: 460_639 nanoseconds.
+ Weight::from_ref_time(591_187_094)
+ .saturating_add(Weight::from_proof_size(10042))
+ // Standard Error: 1_233_792
+ .saturating_add(Weight::from_ref_time(160_874_477).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(51_u64))
.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
@@ -3212,47 +3216,47 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 10]`.
fn seal_contains_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `871 + r * (23100 ±0)`
- // Estimated: `873 + r * (23099 ±0)`
- // Minimum execution time: 375_325 nanoseconds.
- Weight::from_ref_time(305_508_307)
- .saturating_add(Weight::from_proof_size(873))
- // Standard Error: 715_627
- .saturating_add(Weight::from_ref_time(369_985_438).saturating_mul(r.into()))
+ // Measured: `914 + r * (23098 ±0)`
+ // Estimated: `920 + r * (23098 ±0)`
+ // Minimum execution time: 374_272 nanoseconds.
+ Weight::from_ref_time(311_446_269)
+ .saturating_add(Weight::from_proof_size(920))
+ // Standard Error: 630_307
+ .saturating_add(Weight::from_ref_time(357_134_931).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(23099).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(23098).saturating_mul(r.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `n` is `[0, 8]`.
fn seal_contains_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `14814 + n * (175782 ±0)`
- // Estimated: `9502 + n * (176872 ±75)`
- // Minimum execution time: 457_128 nanoseconds.
- Weight::from_ref_time(582_799_799)
- .saturating_add(Weight::from_proof_size(9502))
- // Standard Error: 1_151_126
- .saturating_add(Weight::from_ref_time(63_425_277).saturating_mul(n.into()))
+ // Measured: `14839 + n * (175789 ±0)`
+ // Estimated: `9532 + n * (176874 ±75)`
+ // Minimum execution time: 456_013 nanoseconds.
+ Weight::from_ref_time(575_116_352)
+ .saturating_add(Weight::from_proof_size(9532))
+ // Standard Error: 1_122_298
+ .saturating_add(Weight::from_ref_time(61_786_107).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(51_u64))
.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(176872).saturating_mul(n.into()))
+ .saturating_add(Weight::from_proof_size(176874).saturating_mul(n.into()))
}
/// Storage: Skipped Metadata (r:0 w:0)
/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
/// The range of component `r` is `[0, 10]`.
fn seal_take_storage(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `879 + r * (23740 ±0)`
- // Estimated: `881 + r * (23739 ±0)`
- // Minimum execution time: 375_918 nanoseconds.
- Weight::from_ref_time(293_217_646)
- .saturating_add(Weight::from_proof_size(881))
- // Standard Error: 840_266
- .saturating_add(Weight::from_ref_time(478_374_701).saturating_mul(r.into()))
+ // Measured: `911 + r * (23740 ±0)`
+ // Estimated: `913 + r * (23739 ±0)`
+ // Minimum execution time: 374_621 nanoseconds.
+ Weight::from_ref_time(299_689_489)
+ .saturating_add(Weight::from_proof_size(913))
+ // Standard Error: 757_735
+ .saturating_add(Weight::from_ref_time(465_213_246).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
@@ -3264,13 +3268,13 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 8]`.
fn seal_take_storage_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `15470 + n * (175775 ±0)`
- // Estimated: `10010 + n * (176898 ±76)`
- // Minimum execution time: 484_207 nanoseconds.
- Weight::from_ref_time(664_065_436)
- .saturating_add(Weight::from_proof_size(10010))
- // Standard Error: 1_655_442
- .saturating_add(Weight::from_ref_time(166_258_757).saturating_mul(n.into()))
+ // Measured: `15502 + n * (175775 ±0)`
+ // Estimated: `10042 + n * (176898 ±76)`
+ // Minimum execution time: 481_980 nanoseconds.
+ Weight::from_ref_time(647_289_053)
+ .saturating_add(Weight::from_proof_size(10042))
+ // Standard Error: 1_556_155
+ .saturating_add(Weight::from_ref_time(166_592_657).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(51_u64))
.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(n.into())))
.saturating_add(RocksDbWeight::get().writes(48_u64))
@@ -3280,7 +3284,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1602 w:1601)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3290,23 +3294,23 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_transfer(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1393 + r * (3602 ±0)`
- // Estimated: `21258 + r * (216091 ±0)`
- // Minimum execution time: 377_152 nanoseconds.
- Weight::from_ref_time(317_470_910)
- .saturating_add(Weight::from_proof_size(21258))
- // Standard Error: 994_076
- .saturating_add(Weight::from_ref_time(1_409_416_087).saturating_mul(r.into()))
+ // Measured: `1457 + r * (3604 ±0)`
+ // Estimated: `21583 + r * (216101 ±0)`
+ // Minimum execution time: 374_962 nanoseconds.
+ Weight::from_ref_time(313_416_386)
+ .saturating_add(Weight::from_proof_size(21583))
+ // Standard Error: 710_675
+ .saturating_add(Weight::from_ref_time(1_396_551_156).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().reads((80_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(4_u64))
.saturating_add(RocksDbWeight::get().writes((80_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(216091).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(216101).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1601)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:2 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3316,23 +3320,23 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_call(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1551 + r * (20511 ±0)`
- // Estimated: `21848 + r * (498651 ±1)`
- // Minimum execution time: 376_257 nanoseconds.
- Weight::from_ref_time(377_035_000)
- .saturating_add(Weight::from_proof_size(21848))
- // Standard Error: 7_966_778
- .saturating_add(Weight::from_ref_time(28_873_495_129).saturating_mul(r.into()))
+ // Measured: `1609 + r * (23073 ±0)`
+ // Estimated: `22098 + r * (511456 ±1)`
+ // Minimum execution time: 375_916 nanoseconds.
+ Weight::from_ref_time(376_468_000)
+ .saturating_add(Weight::from_proof_size(22098))
+ // Standard Error: 7_246_855
+ .saturating_add(Weight::from_ref_time(28_982_425_139).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().reads((160_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(RocksDbWeight::get().writes((160_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(498651).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(511456).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1536 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3343,22 +3347,22 @@ impl WeightInfo for () {
fn seal_delegate_call(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0 + r * (71670 ±0)`
- // Estimated: `17125 + r * (659927 ±822)`
- // Minimum execution time: 376_544 nanoseconds.
- Weight::from_ref_time(377_490_000)
- .saturating_add(Weight::from_proof_size(17125))
- // Standard Error: 8_608_050
- .saturating_add(Weight::from_ref_time(28_568_714_410).saturating_mul(r.into()))
+ // Estimated: `17285 + r * (659930 ±563)`
+ // Minimum execution time: 375_412 nanoseconds.
+ Weight::from_ref_time(376_493_000)
+ .saturating_add(Weight::from_proof_size(17285))
+ // Standard Error: 8_239_575
+ .saturating_add(Weight::from_ref_time(28_716_347_183).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((150_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(RocksDbWeight::get().writes((75_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(659927).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(659930).saturating_mul(r.into()))
}
/// Storage: System Account (r:82 w:81)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:81 w:81)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:2 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3369,25 +3373,25 @@ impl WeightInfo for () {
/// The range of component `c` is `[0, 1024]`.
fn seal_call_per_transfer_clone_kb(t: u32, c: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `21611 + t * (15369 ±0)`
- // Estimated: `519400 + t * (277320 ±0)`
- // Minimum execution time: 10_322_052 nanoseconds.
- Weight::from_ref_time(9_248_652_894)
- .saturating_add(Weight::from_proof_size(519400))
- // Standard Error: 9_039_638
- .saturating_add(Weight::from_ref_time(1_393_054_441).saturating_mul(t.into()))
- // Standard Error: 13_554
- .saturating_add(Weight::from_ref_time(9_819_606).saturating_mul(c.into()))
+ // Measured: `24269 + t * (16910 ±0)`
+ // Estimated: `532690 + t * (285025 ±0)`
+ // Minimum execution time: 10_443_315 nanoseconds.
+ Weight::from_ref_time(9_342_574_069)
+ .saturating_add(Weight::from_proof_size(532690))
+ // Standard Error: 7_237_279
+ .saturating_add(Weight::from_ref_time(1_390_221_936).saturating_mul(t.into()))
+ // Standard Error: 10_851
+ .saturating_add(Weight::from_ref_time(9_842_151).saturating_mul(c.into()))
.saturating_add(RocksDbWeight::get().reads(167_u64))
.saturating_add(RocksDbWeight::get().reads((81_u64).saturating_mul(t.into())))
.saturating_add(RocksDbWeight::get().writes(163_u64))
.saturating_add(RocksDbWeight::get().writes((81_u64).saturating_mul(t.into())))
- .saturating_add(Weight::from_proof_size(277320).saturating_mul(t.into()))
+ .saturating_add(Weight::from_proof_size(285025).saturating_mul(t.into()))
}
- /// Storage: System Account (r:1602 w:1602)
+ /// Storage: System Account (r:3202 w:3202)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1601 w:1601)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1601 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3401,23 +3405,23 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_instantiate(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1613 + r * (25576 ±0)`
- // Estimated: `25698 + r * (1169112 ±1)`
- // Minimum execution time: 376_639 nanoseconds.
- Weight::from_ref_time(377_892_000)
- .saturating_add(Weight::from_proof_size(25698))
- // Standard Error: 21_259_255
- .saturating_add(Weight::from_ref_time(34_131_174_956).saturating_mul(r.into()))
+ // Measured: `1775 + r * (25568 ±0)`
+ // Estimated: `26563 + r * (1367114 ±2)`
+ // Minimum execution time: 376_418 nanoseconds.
+ Weight::from_ref_time(377_292_000)
+ .saturating_add(Weight::from_proof_size(26563))
+ // Standard Error: 32_312_545
+ .saturating_add(Weight::from_ref_time(35_904_826_312).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(8_u64))
- .saturating_add(RocksDbWeight::get().reads((400_u64).saturating_mul(r.into())))
+ .saturating_add(RocksDbWeight::get().reads((480_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(5_u64))
- .saturating_add(RocksDbWeight::get().writes((320_u64).saturating_mul(r.into())))
- .saturating_add(Weight::from_proof_size(1169112).saturating_mul(r.into()))
+ .saturating_add(RocksDbWeight::get().writes((400_u64).saturating_mul(r.into())))
+ .saturating_add(Weight::from_proof_size(1367114).saturating_mul(r.into()))
}
- /// Storage: System Account (r:82 w:82)
+ /// Storage: System Account (r:162 w:162)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:81 w:81)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:2 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3433,27 +3437,27 @@ impl WeightInfo for () {
/// The range of component `s` is `[0, 960]`.
fn seal_instantiate_per_transfer_input_salt_kb(t: u32, i: u32, s: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `5666 + t * (17 ±0)`
- // Estimated: `651914 + t * (2762 ±3)`
- // Minimum execution time: 130_366_376 nanoseconds.
- Weight::from_ref_time(9_844_607_874)
- .saturating_add(Weight::from_proof_size(651914))
- // Standard Error: 100_211_149
- .saturating_add(Weight::from_ref_time(390_481_449).saturating_mul(t.into()))
- // Standard Error: 163_416
- .saturating_add(Weight::from_ref_time(126_154_200).saturating_mul(i.into()))
- // Standard Error: 163_416
- .saturating_add(Weight::from_ref_time(126_430_874).saturating_mul(s.into()))
- .saturating_add(RocksDbWeight::get().reads(249_u64))
+ // Measured: `5785 + t * (33 ±0)`
+ // Estimated: `850985 + t * (2671 ±3)`
+ // Minimum execution time: 132_157_340 nanoseconds.
+ Weight::from_ref_time(11_329_968_948)
+ .saturating_add(Weight::from_proof_size(850985))
+ // Standard Error: 99_102_968
+ .saturating_add(Weight::from_ref_time(84_719_458).saturating_mul(t.into()))
+ // Standard Error: 161_609
+ .saturating_add(Weight::from_ref_time(126_156_627).saturating_mul(i.into()))
+ // Standard Error: 161_609
+ .saturating_add(Weight::from_ref_time(126_628_313).saturating_mul(s.into()))
+ .saturating_add(RocksDbWeight::get().reads(329_u64))
.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into())))
- .saturating_add(RocksDbWeight::get().writes(246_u64))
+ .saturating_add(RocksDbWeight::get().writes(326_u64))
.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into())))
- .saturating_add(Weight::from_proof_size(2762).saturating_mul(t.into()))
+ .saturating_add(Weight::from_proof_size(2671).saturating_mul(t.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3463,13 +3467,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_sha2_256(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `839 + r * (642 ±0)`
- // Estimated: `17065 + r * (3210 ±0)`
- // Minimum execution time: 373_848 nanoseconds.
- Weight::from_ref_time(375_974_597)
- .saturating_add(Weight::from_proof_size(17065))
- // Standard Error: 558_923
- .saturating_add(Weight::from_ref_time(42_648_202).saturating_mul(r.into()))
+ // Measured: `871 + r * (642 ±0)`
+ // Estimated: `17225 + r * (3210 ±0)`
+ // Minimum execution time: 373_559 nanoseconds.
+ Weight::from_ref_time(375_166_904)
+ .saturating_add(Weight::from_proof_size(17225))
+ // Standard Error: 125_024
+ .saturating_add(Weight::from_ref_time(42_291_595).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into()))
@@ -3477,7 +3481,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3487,20 +3491,20 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_sha2_256_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1641`
- // Estimated: `21000`
- // Minimum execution time: 417_281 nanoseconds.
- Weight::from_ref_time(418_086_000)
- .saturating_add(Weight::from_proof_size(21000))
- // Standard Error: 43_883
- .saturating_add(Weight::from_ref_time(324_497_460).saturating_mul(n.into()))
+ // Measured: `1673`
+ // Estimated: `21160`
+ // Minimum execution time: 416_233 nanoseconds.
+ Weight::from_ref_time(416_785_000)
+ .saturating_add(Weight::from_proof_size(21160))
+ // Standard Error: 56_223
+ .saturating_add(Weight::from_ref_time(324_513_835).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3510,13 +3514,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_keccak_256(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (642 ±0)`
- // Estimated: `17075 + r * (3210 ±0)`
- // Minimum execution time: 372_362 nanoseconds.
- Weight::from_ref_time(374_975_677)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 307_932
- .saturating_add(Weight::from_ref_time(57_607_522).saturating_mul(r.into()))
+ // Measured: `873 + r * (642 ±0)`
+ // Estimated: `17235 + r * (3210 ±0)`
+ // Minimum execution time: 371_735 nanoseconds.
+ Weight::from_ref_time(375_979_430)
+ .saturating_add(Weight::from_proof_size(17235))
+ // Standard Error: 968_037
+ .saturating_add(Weight::from_ref_time(57_780_769).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into()))
@@ -3524,7 +3528,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3534,20 +3538,20 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_keccak_256_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1643`
- // Estimated: `21040`
- // Minimum execution time: 431_034 nanoseconds.
- Weight::from_ref_time(431_571_000)
- .saturating_add(Weight::from_proof_size(21040))
- // Standard Error: 80_071
- .saturating_add(Weight::from_ref_time(261_645_325).saturating_mul(n.into()))
+ // Measured: `1675`
+ // Estimated: `21205`
+ // Minimum execution time: 428_196 nanoseconds.
+ Weight::from_ref_time(429_438_000)
+ .saturating_add(Weight::from_proof_size(21205))
+ // Standard Error: 57_860
+ .saturating_add(Weight::from_ref_time(260_917_896).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3557,13 +3561,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_blake2_256(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (642 ±0)`
- // Estimated: `17075 + r * (3210 ±0)`
- // Minimum execution time: 372_069 nanoseconds.
- Weight::from_ref_time(374_200_608)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 171_799
- .saturating_add(Weight::from_ref_time(32_843_391).saturating_mul(r.into()))
+ // Measured: `873 + r * (642 ±0)`
+ // Estimated: `17235 + r * (3210 ±0)`
+ // Minimum execution time: 371_412 nanoseconds.
+ Weight::from_ref_time(373_635_818)
+ .saturating_add(Weight::from_proof_size(17235))
+ // Standard Error: 222_973
+ .saturating_add(Weight::from_ref_time(33_347_181).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3210).saturating_mul(r.into()))
@@ -3571,7 +3575,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3581,20 +3585,20 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_blake2_256_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1643`
- // Estimated: `21010`
- // Minimum execution time: 406_143 nanoseconds.
- Weight::from_ref_time(406_744_000)
- .saturating_add(Weight::from_proof_size(21010))
- // Standard Error: 48_038
- .saturating_add(Weight::from_ref_time(103_286_295).saturating_mul(n.into()))
+ // Measured: `1675`
+ // Estimated: `21180`
+ // Minimum execution time: 405_858 nanoseconds.
+ Weight::from_ref_time(406_498_000)
+ .saturating_add(Weight::from_proof_size(21180))
+ // Standard Error: 48_388
+ .saturating_add(Weight::from_ref_time(103_283_157).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3604,13 +3608,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_hash_blake2_128(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `841 + r * (679 ±0)`
- // Estimated: `17075 + r * (3395 ±0)`
- // Minimum execution time: 372_201 nanoseconds.
- Weight::from_ref_time(374_049_708)
- .saturating_add(Weight::from_proof_size(17075))
- // Standard Error: 387_179
- .saturating_add(Weight::from_ref_time(38_857_191).saturating_mul(r.into()))
+ // Measured: `873 + r * (679 ±0)`
+ // Estimated: `17235 + r * (3395 ±0)`
+ // Minimum execution time: 371_746 nanoseconds.
+ Weight::from_ref_time(373_538_171)
+ .saturating_add(Weight::from_proof_size(17235))
+ // Standard Error: 387_332
+ .saturating_add(Weight::from_ref_time(35_933_528).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(3395).saturating_mul(r.into()))
@@ -3618,7 +3622,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3628,20 +3632,20 @@ impl WeightInfo for () {
/// The range of component `n` is `[0, 1024]`.
fn seal_hash_blake2_128_per_kb(n: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `1643`
- // Estimated: `21050`
- // Minimum execution time: 405_819 nanoseconds.
- Weight::from_ref_time(406_364_000)
- .saturating_add(Weight::from_proof_size(21050))
- // Standard Error: 46_248
- .saturating_add(Weight::from_ref_time(103_189_157).saturating_mul(n.into()))
+ // Measured: `1675`
+ // Estimated: `21225`
+ // Minimum execution time: 405_752 nanoseconds.
+ Weight::from_ref_time(406_417_000)
+ .saturating_add(Weight::from_proof_size(21225))
+ // Standard Error: 47_051
+ .saturating_add(Weight::from_ref_time(103_325_027).saturating_mul(n.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3651,13 +3655,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_ecdsa_recover(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `885 + r * (6083 ±0)`
- // Estimated: `17295 + r * (30415 ±0)`
- // Minimum execution time: 374_836 nanoseconds.
- Weight::from_ref_time(379_385_500)
- .saturating_add(Weight::from_proof_size(17295))
- // Standard Error: 1_694_427
- .saturating_add(Weight::from_ref_time(3_021_801_000).saturating_mul(r.into()))
+ // Measured: `917 + r * (6083 ±0)`
+ // Estimated: `17455 + r * (30415 ±0)`
+ // Minimum execution time: 373_882 nanoseconds.
+ Weight::from_ref_time(376_553_787)
+ .saturating_add(Weight::from_proof_size(17455))
+ // Standard Error: 912_833
+ .saturating_add(Weight::from_ref_time(3_021_100_412).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(30415).saturating_mul(r.into()))
@@ -3665,7 +3669,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3675,13 +3679,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 1]`.
fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `854 + r * (3362 ±0)`
- // Estimated: `17140 + r * (16810 ±0)`
- // Minimum execution time: 374_223 nanoseconds.
- Weight::from_ref_time(376_120_230)
- .saturating_add(Weight::from_proof_size(17140))
- // Standard Error: 619_576
- .saturating_add(Weight::from_ref_time(754_257_969).saturating_mul(r.into()))
+ // Measured: `886 + r * (3362 ±0)`
+ // Estimated: `17300 + r * (16810 ±0)`
+ // Minimum execution time: 373_673 nanoseconds.
+ Weight::from_ref_time(375_712_961)
+ .saturating_add(Weight::from_proof_size(17300))
+ // Standard Error: 596_297
+ .saturating_add(Weight::from_ref_time(738_257_638).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(16810).saturating_mul(r.into()))
@@ -3689,7 +3693,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1536 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3702,12 +3706,12 @@ impl WeightInfo for () {
fn seal_set_code_hash(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0 + r * (79300 ±0)`
- // Estimated: `64652 + r * (942952 ±829)`
- // Minimum execution time: 374_442 nanoseconds.
- Weight::from_ref_time(375_591_000)
- .saturating_add(Weight::from_proof_size(64652))
- // Standard Error: 3_764_193
- .saturating_add(Weight::from_ref_time(1_552_885_601).saturating_mul(r.into()))
+ // Estimated: `64844 + r * (942952 ±833)`
+ // Minimum execution time: 374_097 nanoseconds.
+ Weight::from_ref_time(374_985_000)
+ .saturating_add(Weight::from_proof_size(64844))
+ // Standard Error: 3_772_336
+ .saturating_add(Weight::from_ref_time(1_546_402_854).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().reads((225_u64).saturating_mul(r.into())))
.saturating_add(RocksDbWeight::get().writes(3_u64))
@@ -3717,7 +3721,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3727,13 +3731,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_reentrance_count(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `837 + r * (240 ±0)`
- // Estimated: `17055 + r * (1200 ±0)`
- // Minimum execution time: 374_922 nanoseconds.
- Weight::from_ref_time(376_234_094)
- .saturating_add(Weight::from_proof_size(17055))
- // Standard Error: 45_995
- .saturating_add(Weight::from_ref_time(11_606_505).saturating_mul(r.into()))
+ // Measured: `869 + r * (240 ±0)`
+ // Estimated: `17215 + r * (1200 ±0)`
+ // Minimum execution time: 374_249 nanoseconds.
+ Weight::from_ref_time(377_990_998)
+ .saturating_add(Weight::from_proof_size(17215))
+ // Standard Error: 38_133
+ .saturating_add(Weight::from_ref_time(11_483_273).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
.saturating_add(Weight::from_proof_size(1200).saturating_mul(r.into()))
@@ -3741,7 +3745,7 @@ impl WeightInfo for () {
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3751,21 +3755,21 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_account_reentrance_count(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `2056 + r * (3153 ±0)`
- // Estimated: `21730 + r * (15870 ±2)`
- // Minimum execution time: 376_762 nanoseconds.
- Weight::from_ref_time(396_934_359)
- .saturating_add(Weight::from_proof_size(21730))
- // Standard Error: 68_263
- .saturating_add(Weight::from_ref_time(18_367_270).saturating_mul(r.into()))
+ // Measured: `2102 + r * (3154 ±0)`
+ // Estimated: `21980 + r * (15875 ±2)`
+ // Minimum execution time: 375_552 nanoseconds.
+ Weight::from_ref_time(400_624_032)
+ .saturating_add(Weight::from_proof_size(21980))
+ // Standard Error: 82_523
+ .saturating_add(Weight::from_ref_time(18_057_327).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(6_u64))
.saturating_add(RocksDbWeight::get().writes(3_u64))
- .saturating_add(Weight::from_proof_size(15870).saturating_mul(r.into()))
+ .saturating_add(Weight::from_proof_size(15875).saturating_mul(r.into()))
}
/// Storage: System Account (r:1 w:0)
/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: Measured)
/// Storage: Contracts ContractInfoOf (r:1 w:1)
- /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(258), added: 2733, mode: Measured)
+ /// Proof: Contracts ContractInfoOf (max_values: None, max_size: Some(290), added: 2765, mode: Measured)
/// Storage: Contracts CodeStorage (r:1 w:0)
/// Proof: Contracts CodeStorage (max_values: None, max_size: Some(126001), added: 128476, mode: Measured)
/// Storage: Timestamp Now (r:1 w:0)
@@ -3777,13 +3781,13 @@ impl WeightInfo for () {
/// The range of component `r` is `[0, 20]`.
fn seal_instantiation_nonce(r: u32, ) -> Weight {
// Proof Size summary in bytes:
- // Measured: `840 + r * (240 ±0)`
- // Estimated: `18405 + r * (1440 ±0)`
- // Minimum execution time: 374_257 nanoseconds.
- Weight::from_ref_time(380_453_380)
- .saturating_add(Weight::from_proof_size(18405))
- // Standard Error: 42_718
- .saturating_add(Weight::from_ref_time(9_355_253).saturating_mul(r.into()))
+ // Measured: `872 + r * (240 ±0)`
+ // Estimated: `18598 + r * (1440 ±0)`
+ // Minimum execution time: 373_899 nanoseconds.
+ Weight::from_ref_time(379_733_943)
+ .saturating_add(Weight::from_proof_size(18598))
+ // Standard Error: 32_022
+ .saturating_add(Weight::from_ref_time(9_381_180).saturating_mul(r.into()))
.saturating_add(RocksDbWeight::get().reads(7_u64))
.saturating_add(RocksDbWeight::get().writes(4_u64))
.saturating_add(Weight::from_proof_size(1440).saturating_mul(r.into()))
@@ -3793,571 +3797,571 @@ impl WeightInfo for () {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 788 nanoseconds.
- Weight::from_ref_time(1_209_829)
+ // Minimum execution time: 834 nanoseconds.
+ Weight::from_ref_time(1_009_646)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 3_436
- .saturating_add(Weight::from_ref_time(409_858).saturating_mul(r.into()))
+ // Standard Error: 388
+ .saturating_add(Weight::from_ref_time(411_979).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64load(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 955 nanoseconds.
- Weight::from_ref_time(1_526_327)
+ // Minimum execution time: 882 nanoseconds.
+ Weight::from_ref_time(1_416_377)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_399
- .saturating_add(Weight::from_ref_time(1_084_504).saturating_mul(r.into()))
+ // Standard Error: 1_133
+ .saturating_add(Weight::from_ref_time(1_075_838).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64store(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 967 nanoseconds.
- Weight::from_ref_time(1_576_183)
+ // Minimum execution time: 878 nanoseconds.
+ Weight::from_ref_time(1_343_056)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 5_719
- .saturating_add(Weight::from_ref_time(1_006_742).saturating_mul(r.into()))
+ // Standard Error: 426
+ .saturating_add(Weight::from_ref_time(1_001_214).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_select(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 849 nanoseconds.
- Weight::from_ref_time(1_106_539)
+ // Minimum execution time: 796 nanoseconds.
+ Weight::from_ref_time(1_079_086)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 445
- .saturating_add(Weight::from_ref_time(1_149_752).saturating_mul(r.into()))
+ // Standard Error: 409
+ .saturating_add(Weight::from_ref_time(1_149_188).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_if(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 829 nanoseconds.
- Weight::from_ref_time(1_171_360)
+ // Minimum execution time: 800 nanoseconds.
+ Weight::from_ref_time(1_044_184)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 552
- .saturating_add(Weight::from_ref_time(1_309_914).saturating_mul(r.into()))
+ // Standard Error: 707
+ .saturating_add(Weight::from_ref_time(1_315_686).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_br(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 835 nanoseconds.
- Weight::from_ref_time(1_125_578)
+ // Minimum execution time: 807 nanoseconds.
+ Weight::from_ref_time(1_049_633)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 374
- .saturating_add(Weight::from_ref_time(641_683).saturating_mul(r.into()))
+ // Standard Error: 361
+ .saturating_add(Weight::from_ref_time(640_530).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_br_if(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 816 nanoseconds.
- Weight::from_ref_time(1_032_093)
+ // Minimum execution time: 774 nanoseconds.
+ Weight::from_ref_time(1_124_053)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 811
- .saturating_add(Weight::from_ref_time(956_228).saturating_mul(r.into()))
+ // Standard Error: 784
+ .saturating_add(Weight::from_ref_time(949_398).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_br_table(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 801 nanoseconds.
- Weight::from_ref_time(816_764)
+ // Minimum execution time: 810 nanoseconds.
+ Weight::from_ref_time(676_581)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_669
- .saturating_add(Weight::from_ref_time(1_166_556).saturating_mul(r.into()))
+ // Standard Error: 2_356
+ .saturating_add(Weight::from_ref_time(1_163_465).saturating_mul(r.into()))
}
/// The range of component `e` is `[1, 256]`.
fn instr_br_table_per_entry(e: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_639 nanoseconds.
- Weight::from_ref_time(2_905_554)
+ // Minimum execution time: 2_580 nanoseconds.
+ Weight::from_ref_time(2_835_656)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 62
- .saturating_add(Weight::from_ref_time(4_438).saturating_mul(e.into()))
+ // Standard Error: 71
+ .saturating_add(Weight::from_ref_time(4_686).saturating_mul(e.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_call(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 831 nanoseconds.
- Weight::from_ref_time(1_729_584)
+ // Minimum execution time: 826 nanoseconds.
+ Weight::from_ref_time(1_625_698)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 33_753
- .saturating_add(Weight::from_ref_time(2_380_315).saturating_mul(r.into()))
+ // Standard Error: 1_740
+ .saturating_add(Weight::from_ref_time(2_332_187).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_call_indirect(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 964 nanoseconds.
- Weight::from_ref_time(2_445_291)
+ // Minimum execution time: 901 nanoseconds.
+ Weight::from_ref_time(2_338_620)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 3_285
- .saturating_add(Weight::from_ref_time(2_938_681).saturating_mul(r.into()))
+ // Standard Error: 1_642
+ .saturating_add(Weight::from_ref_time(2_924_090).saturating_mul(r.into()))
}
/// The range of component `p` is `[0, 128]`.
fn instr_call_indirect_per_param(p: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 4_809 nanoseconds.
- Weight::from_ref_time(6_763_286)
+ // Minimum execution time: 4_670 nanoseconds.
+ Weight::from_ref_time(5_556_246)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 3_994
- .saturating_add(Weight::from_ref_time(217_632).saturating_mul(p.into()))
+ // Standard Error: 1_491
+ .saturating_add(Weight::from_ref_time(228_965).saturating_mul(p.into()))
}
/// The range of component `l` is `[0, 1024]`.
fn instr_call_per_local(l: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 3_138 nanoseconds.
- Weight::from_ref_time(3_894_816)
+ // Minimum execution time: 3_099 nanoseconds.
+ Weight::from_ref_time(3_896_177)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 131
- .saturating_add(Weight::from_ref_time(91_699).saturating_mul(l.into()))
+ // Standard Error: 99
+ .saturating_add(Weight::from_ref_time(91_304).saturating_mul(l.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_local_get(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_959 nanoseconds.
- Weight::from_ref_time(3_271_550)
+ // Minimum execution time: 3_042 nanoseconds.
+ Weight::from_ref_time(3_334_621)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 223
- .saturating_add(Weight::from_ref_time(460_056).saturating_mul(r.into()))
+ // Standard Error: 793
+ .saturating_add(Weight::from_ref_time(459_346).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_local_set(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_970 nanoseconds.
- Weight::from_ref_time(3_216_157)
+ // Minimum execution time: 2_968 nanoseconds.
+ Weight::from_ref_time(3_235_286)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 413
- .saturating_add(Weight::from_ref_time(485_842).saturating_mul(r.into()))
+ // Standard Error: 427
+ .saturating_add(Weight::from_ref_time(485_454).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_local_tee(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 2_980 nanoseconds.
- Weight::from_ref_time(3_323_878)
+ // Minimum execution time: 3_012 nanoseconds.
+ Weight::from_ref_time(3_303_555)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_652
- .saturating_add(Weight::from_ref_time(660_257).saturating_mul(r.into()))
+ // Standard Error: 371
+ .saturating_add(Weight::from_ref_time(657_811).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_global_get(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 917 nanoseconds.
- Weight::from_ref_time(1_445_816)
+ // Minimum execution time: 865 nanoseconds.
+ Weight::from_ref_time(1_249_987)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 5_642
- .saturating_add(Weight::from_ref_time(894_521).saturating_mul(r.into()))
+ // Standard Error: 417
+ .saturating_add(Weight::from_ref_time(896_704).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_global_set(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 965 nanoseconds.
- Weight::from_ref_time(1_373_722)
+ // Minimum execution time: 866 nanoseconds.
+ Weight::from_ref_time(1_216_218)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 1_157
- .saturating_add(Weight::from_ref_time(917_643).saturating_mul(r.into()))
+ // Standard Error: 503
+ .saturating_add(Weight::from_ref_time(919_719).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_memory_current(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 982 nanoseconds.
- Weight::from_ref_time(1_240_280)
+ // Minimum execution time: 921 nanoseconds.
+ Weight::from_ref_time(1_228_408)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 308
- .saturating_add(Weight::from_ref_time(817_972).saturating_mul(r.into()))
+ // Standard Error: 309
+ .saturating_add(Weight::from_ref_time(813_007).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 1]`.
fn instr_memory_grow(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 858 nanoseconds.
- Weight::from_ref_time(962_183)
+ // Minimum execution time: 820 nanoseconds.
+ Weight::from_ref_time(914_830)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 6_701
- .saturating_add(Weight::from_ref_time(239_704_216).saturating_mul(r.into()))
+ // Standard Error: 6_018
+ .saturating_add(Weight::from_ref_time(237_062_769).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64clz(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 807 nanoseconds.
- Weight::from_ref_time(1_132_872)
+ // Minimum execution time: 812 nanoseconds.
+ Weight::from_ref_time(1_554_406)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 303
- .saturating_add(Weight::from_ref_time(633_832).saturating_mul(r.into()))
+ // Standard Error: 9_979
+ .saturating_add(Weight::from_ref_time(625_434).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ctz(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 823 nanoseconds.
- Weight::from_ref_time(1_267_518)
+ // Minimum execution time: 798 nanoseconds.
+ Weight::from_ref_time(1_095_113)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 483
- .saturating_add(Weight::from_ref_time(632_620).saturating_mul(r.into()))
+ // Standard Error: 243
+ .saturating_add(Weight::from_ref_time(634_204).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64popcnt(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 857 nanoseconds.
- Weight::from_ref_time(1_105_214)
+ // Minimum execution time: 792 nanoseconds.
+ Weight::from_ref_time(1_109_845)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 285
- .saturating_add(Weight::from_ref_time(635_039).saturating_mul(r.into()))
+ // Standard Error: 14_944
+ .saturating_add(Weight::from_ref_time(658_834).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64eqz(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 821 nanoseconds.
- Weight::from_ref_time(750_223)
+ // Minimum execution time: 815 nanoseconds.
+ Weight::from_ref_time(1_068_916)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 15_923
- .saturating_add(Weight::from_ref_time(686_322).saturating_mul(r.into()))
+ // Standard Error: 327
+ .saturating_add(Weight::from_ref_time(652_897).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64extendsi32(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 797 nanoseconds.
- Weight::from_ref_time(1_145_072)
+ // Minimum execution time: 798 nanoseconds.
+ Weight::from_ref_time(1_069_745)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 311
- .saturating_add(Weight::from_ref_time(618_147).saturating_mul(r.into()))
+ // Standard Error: 306
+ .saturating_add(Weight::from_ref_time(618_481).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64extendui32(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 803 nanoseconds.
- Weight::from_ref_time(1_139_498)
+ // Minimum execution time: 799 nanoseconds.
+ Weight::from_ref_time(1_398_001)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 284
- .saturating_add(Weight::from_ref_time(617_393).saturating_mul(r.into()))
+ // Standard Error: 6_234
+ .saturating_add(Weight::from_ref_time(611_399).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i32wrapi64(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 814 nanoseconds.
- Weight::from_ref_time(1_099_405)
+ // Minimum execution time: 811 nanoseconds.
+ Weight::from_ref_time(1_098_083)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 663
- .saturating_add(Weight::from_ref_time(618_565).saturating_mul(r.into()))
+ // Standard Error: 297
+ .saturating_add(Weight::from_ref_time(617_692).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64eq(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 819 nanoseconds.
- Weight::from_ref_time(1_199_220)
+ // Minimum execution time: 815 nanoseconds.
+ Weight::from_ref_time(1_046_922)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 485
- .saturating_add(Weight::from_ref_time(906_878).saturating_mul(r.into()))
+ // Standard Error: 335
+ .saturating_add(Weight::from_ref_time(909_196).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ne(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 822 nanoseconds.
- Weight::from_ref_time(274_212)
+ // Minimum execution time: 805 nanoseconds.
+ Weight::from_ref_time(1_093_667)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 29_294
- .saturating_add(Weight::from_ref_time(971_608).saturating_mul(r.into()))
+ // Standard Error: 233
+ .saturating_add(Weight::from_ref_time(907_378).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64lts(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 796 nanoseconds.
- Weight::from_ref_time(1_396_586)
+ // Minimum execution time: 805 nanoseconds.
+ Weight::from_ref_time(1_290_591)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 7_205
- .saturating_add(Weight::from_ref_time(903_202).saturating_mul(r.into()))
+ // Standard Error: 3_201
+ .saturating_add(Weight::from_ref_time(902_006).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ltu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 833 nanoseconds.
- Weight::from_ref_time(1_115_115)
+ // Minimum execution time: 783 nanoseconds.
+ Weight::from_ref_time(1_159_977)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 310
- .saturating_add(Weight::from_ref_time(908_195).saturating_mul(r.into()))
+ // Standard Error: 2_310
+ .saturating_add(Weight::from_ref_time(906_489).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64gts(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 854 nanoseconds.
- Weight::from_ref_time(1_170_419)
+ // Minimum execution time: 790 nanoseconds.
+ Weight::from_ref_time(1_109_719)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 298
- .saturating_add(Weight::from_ref_time(907_171).saturating_mul(r.into()))
+ // Standard Error: 261
+ .saturating_add(Weight::from_ref_time(906_614).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64gtu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 822 nanoseconds.
- Weight::from_ref_time(1_186_349)
+ // Minimum execution time: 776 nanoseconds.
+ Weight::from_ref_time(1_076_567)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 302
- .saturating_add(Weight::from_ref_time(917_857).saturating_mul(r.into()))
+ // Standard Error: 348
+ .saturating_add(Weight::from_ref_time(919_374).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64les(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 807 nanoseconds.
- Weight::from_ref_time(1_127_093)
+ // Minimum execution time: 780 nanoseconds.
+ Weight::from_ref_time(1_069_663)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 1_891
- .saturating_add(Weight::from_ref_time(910_738).saturating_mul(r.into()))
+ // Standard Error: 265
+ .saturating_add(Weight::from_ref_time(908_037).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64leu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 819 nanoseconds.
- Weight::from_ref_time(1_143_022)
+ // Minimum execution time: 832 nanoseconds.
+ Weight::from_ref_time(930_920)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 309
- .saturating_add(Weight::from_ref_time(919_047).saturating_mul(r.into()))
+ // Standard Error: 2_170
+ .saturating_add(Weight::from_ref_time(929_811).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64ges(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 788 nanoseconds.
- Weight::from_ref_time(1_116_914)
+ // Minimum execution time: 787 nanoseconds.
+ Weight::from_ref_time(1_087_325)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 643
- .saturating_add(Weight::from_ref_time(911_159).saturating_mul(r.into()))
+ // Standard Error: 315
+ .saturating_add(Weight::from_ref_time(908_321).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64geu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 791 nanoseconds.
- Weight::from_ref_time(1_123_747)
+ // Minimum execution time: 798 nanoseconds.
+ Weight::from_ref_time(1_029_132)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 583
- .saturating_add(Weight::from_ref_time(910_242).saturating_mul(r.into()))
+ // Standard Error: 2_095
+ .saturating_add(Weight::from_ref_time(913_553).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64add(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 787 nanoseconds.
- Weight::from_ref_time(1_109_471)
+ // Minimum execution time: 791 nanoseconds.
+ Weight::from_ref_time(1_086_314)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 305
- .saturating_add(Weight::from_ref_time(897_608).saturating_mul(r.into()))
+ // Standard Error: 197
+ .saturating_add(Weight::from_ref_time(896_392).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64sub(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 821 nanoseconds.
- Weight::from_ref_time(1_098_631)
+ // Minimum execution time: 793 nanoseconds.
+ Weight::from_ref_time(1_078_172)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 523
- .saturating_add(Weight::from_ref_time(887_814).saturating_mul(r.into()))
+ // Standard Error: 404
+ .saturating_add(Weight::from_ref_time(886_329).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64mul(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 794 nanoseconds.
- Weight::from_ref_time(1_166_332)
+ // Minimum execution time: 799 nanoseconds.
+ Weight::from_ref_time(1_095_010)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 384
- .saturating_add(Weight::from_ref_time(885_584).saturating_mul(r.into()))
+ // Standard Error: 431
+ .saturating_add(Weight::from_ref_time(886_513).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64divs(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 822 nanoseconds.
- Weight::from_ref_time(1_155_826)
+ // Minimum execution time: 810 nanoseconds.
+ Weight::from_ref_time(1_114_325)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 521
- .saturating_add(Weight::from_ref_time(1_520_958).saturating_mul(r.into()))
+ // Standard Error: 452
+ .saturating_add(Weight::from_ref_time(1_521_849).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64divu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 881 nanoseconds.
- Weight::from_ref_time(1_158_125)
+ // Minimum execution time: 784 nanoseconds.
+ Weight::from_ref_time(1_123_153)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 624
- .saturating_add(Weight::from_ref_time(1_458_378).saturating_mul(r.into()))
+ // Standard Error: 475
+ .saturating_add(Weight::from_ref_time(1_457_746).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64rems(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 827 nanoseconds.
- Weight::from_ref_time(1_209_535)
+ // Minimum execution time: 809 nanoseconds.
+ Weight::from_ref_time(1_145_906)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 399
- .saturating_add(Weight::from_ref_time(1_547_640).saturating_mul(r.into()))
+ // Standard Error: 718
+ .saturating_add(Weight::from_ref_time(1_549_964).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64remu(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 801 nanoseconds.
- Weight::from_ref_time(1_313_872)
+ // Minimum execution time: 803 nanoseconds.
+ Weight::from_ref_time(1_110_328)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 2_175
- .saturating_add(Weight::from_ref_time(1_449_416).saturating_mul(r.into()))
+ // Standard Error: 627
+ .saturating_add(Weight::from_ref_time(1_453_013).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64and(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 827 nanoseconds.
- Weight::from_ref_time(1_093_874)
+ // Minimum execution time: 786 nanoseconds.
+ Weight::from_ref_time(1_108_792)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 708
- .saturating_add(Weight::from_ref_time(901_450).saturating_mul(r.into()))
+ // Standard Error: 286
+ .saturating_add(Weight::from_ref_time(897_035).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64or(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 824 nanoseconds.
- Weight::from_ref_time(1_164_076)
+ // Minimum execution time: 787 nanoseconds.
+ Weight::from_ref_time(830_000)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 623
- .saturating_add(Weight::from_ref_time(897_579).saturating_mul(r.into()))
+ // Standard Error: 15_995
+ .saturating_add(Weight::from_ref_time(963_344).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64xor(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 789 nanoseconds.
- Weight::from_ref_time(1_113_915)
+ // Minimum execution time: 773 nanoseconds.
+ Weight::from_ref_time(1_082_459)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 390
- .saturating_add(Weight::from_ref_time(897_354).saturating_mul(r.into()))
+ // Standard Error: 330
+ .saturating_add(Weight::from_ref_time(897_077).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64shl(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 811 nanoseconds.
- Weight::from_ref_time(1_117_366)
+ // Minimum execution time: 810 nanoseconds.
+ Weight::from_ref_time(1_325_815)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 437
- .saturating_add(Weight::from_ref_time(903_759).saturating_mul(r.into()))
+ // Standard Error: 3_352
+ .saturating_add(Weight::from_ref_time(899_555).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64shrs(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 846 nanoseconds.
- Weight::from_ref_time(1_103_954)
+ // Minimum execution time: 808 nanoseconds.
+ Weight::from_ref_time(1_085_903)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 414
- .saturating_add(Weight::from_ref_time(903_429).saturating_mul(r.into()))
+ // Standard Error: 430
+ .saturating_add(Weight::from_ref_time(903_249).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64shru(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 803 nanoseconds.
- Weight::from_ref_time(1_124_328)
+ // Minimum execution time: 792 nanoseconds.
+ Weight::from_ref_time(1_091_261)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 410
- .saturating_add(Weight::from_ref_time(903_216).saturating_mul(r.into()))
+ // Standard Error: 312
+ .saturating_add(Weight::from_ref_time(902_245).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64rotl(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 810 nanoseconds.
- Weight::from_ref_time(1_131_433)
+ // Minimum execution time: 807 nanoseconds.
+ Weight::from_ref_time(1_121_052)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 402
- .saturating_add(Weight::from_ref_time(903_381).saturating_mul(r.into()))
+ // Standard Error: 506
+ .saturating_add(Weight::from_ref_time(902_772).saturating_mul(r.into()))
}
/// The range of component `r` is `[0, 50]`.
fn instr_i64rotr(r: u32, ) -> Weight {
// Proof Size summary in bytes:
// Measured: `0`
// Estimated: `0`
- // Minimum execution time: 807 nanoseconds.
- Weight::from_ref_time(1_144_933)
+ // Minimum execution time: 823 nanoseconds.
+ Weight::from_ref_time(1_317_597)
.saturating_add(Weight::from_proof_size(0))
- // Standard Error: 373
- .saturating_add(Weight::from_ref_time(902_918).saturating_mul(r.into()))
+ // Standard Error: 6_219
+ .saturating_add(Weight::from_ref_time(896_692).saturating_mul(r.into()))
}
}