diff --git a/bin/node/runtime/src/lib.rs b/bin/node/runtime/src/lib.rs index 8129fec68ada4..fc165b014e27a 100644 --- a/bin/node/runtime/src/lib.rs +++ b/bin/node/runtime/src/lib.rs @@ -207,7 +207,7 @@ impl pallet_multisig::Trait for Runtime { type DepositBase = DepositBase; type DepositFactor = DepositFactor; type MaxSignatories = MaxSignatories; - type WeightInfo = (); + type WeightInfo = weights::pallet_multisig::WeightInfo; } parameter_types! { diff --git a/bin/node/runtime/src/weights/mod.rs b/bin/node/runtime/src/weights/mod.rs index e2e65595d32d1..ce4d8583200e2 100644 --- a/bin/node/runtime/src/weights/mod.rs +++ b/bin/node/runtime/src/weights/mod.rs @@ -23,6 +23,7 @@ pub mod pallet_democracy; pub mod pallet_identity; pub mod pallet_indices; pub mod pallet_im_online; +pub mod pallet_multisig; pub mod pallet_proxy; pub mod pallet_scheduler; pub mod pallet_session; diff --git a/bin/node/runtime/src/weights/pallet_multisig.rs b/bin/node/runtime/src/weights/pallet_multisig.rs new file mode 100644 index 0000000000000..1de1d9a67f441 --- /dev/null +++ b/bin/node/runtime/src/weights/pallet_multisig.rs @@ -0,0 +1,90 @@ +// This file is part of Substrate. + +// Copyright (C) 2019-2020 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. + +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 2.0.0-rc6 + +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::weights::{Weight, constants::RocksDbWeight as DbWeight}; + +pub struct WeightInfo; +impl pallet_multisig::WeightInfo for WeightInfo { + fn as_multi_threshold_1(z: u32, ) -> Weight { + (17_161_000 as Weight) + .saturating_add((1_000 as Weight).saturating_mul(z as Weight)) + } + fn as_multi_create(s: u32, z: u32, ) -> Weight { + (79_857_000 as Weight) + .saturating_add((131_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((1_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn as_multi_create_store(s: u32, z: u32, ) -> Weight { + (90_218_000 as Weight) + .saturating_add((129_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((3_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(3 as Weight)) + .saturating_add(DbWeight::get().writes(2 as Weight)) + } + fn as_multi_approve(s: u32, z: u32, ) -> Weight { + (48_402_000 as Weight) + .saturating_add((132_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((1_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(1 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn as_multi_approve_store(s: u32, z: u32, ) -> Weight { + (88_390_000 as Weight) + .saturating_add((120_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((3_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(2 as Weight)) + } + fn as_multi_complete(s: u32, z: u32, ) -> Weight { + (98_960_000 as Weight) + .saturating_add((276_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((6_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(3 as Weight)) + .saturating_add(DbWeight::get().writes(3 as Weight)) + } + fn approve_as_multi_create(s: u32, ) -> Weight { + (80_185_000 as Weight) + .saturating_add((121_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn approve_as_multi_approve(s: u32, ) -> Weight { + (48_386_000 as Weight) + .saturating_add((143_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(1 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn approve_as_multi_complete(s: u32, ) -> Weight { + (177_181_000 as Weight) + .saturating_add((273_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(3 as Weight)) + .saturating_add(DbWeight::get().writes(3 as Weight)) + } + fn cancel_as_multi(s: u32, ) -> Weight { + (126_334_000 as Weight) + .saturating_add((124_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(2 as Weight)) + } +} diff --git a/frame/multisig/src/benchmarking.rs b/frame/multisig/src/benchmarking.rs index 8113d179cd157..bf89ec8b09bd4 100644 --- a/frame/multisig/src/benchmarking.rs +++ b/frame/multisig/src/benchmarking.rs @@ -59,6 +59,9 @@ benchmarks! { let call_hash = call.using_encoded(blake2_256); let multi_account_id = Multisig::::multi_account_id(&signatories, 1); let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: _(RawOrigin::Signed(caller.clone()), signatories, Box::new(call)) verify { // If the benchmark resolves, then the call was dispatched successfully. @@ -73,9 +76,13 @@ benchmarks! { let call_hash = blake2_256(&call); let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: as_multi(RawOrigin::Signed(caller), s as u16, signatories, None, call, false, 0) verify { assert!(Multisigs::::contains_key(multi_account_id, call_hash)); + assert!(!Calls::::contains_key(call_hash)); } as_multi_create_store { @@ -88,6 +95,9 @@ benchmarks! { let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; T::Currency::make_free_balance_be(&caller, BalanceOf::::max_value()); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: as_multi(RawOrigin::Signed(caller), s as u16, signatories, None, call, true, 0) verify { assert!(Multisigs::::contains_key(multi_account_id, call_hash)); @@ -108,13 +118,43 @@ benchmarks! { let timepoint = Multisig::::timepoint(); // Create the multi, storing for worst case Multisig::::as_multi(RawOrigin::Signed(caller).into(), s as u16, signatories, None, call.clone(), true, 0)?; + assert!(Calls::::contains_key(call_hash)); let caller2 = signatories2.remove(0); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller2); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call, false, 0) verify { let multisig = Multisigs::::get(multi_account_id, call_hash).ok_or("multisig not created")?; assert_eq!(multisig.approvals.len(), 2); } + as_multi_approve_store { + // Signatories, need at least 3 people (so we don't complete the multisig) + let s in 3 .. T::MaxSignatories::get() as u32; + // Transaction Length + let z in 0 .. 10_000; + let (mut signatories, call) = setup_multi::(s, z)?; + let call_hash = blake2_256(&call); + let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); + let mut signatories2 = signatories.clone(); + let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; + // before the call, get the timepoint + let timepoint = Multisig::::timepoint(); + // Create the multi, not storing + Multisig::::as_multi(RawOrigin::Signed(caller).into(), s as u16, signatories, None, call.clone(), false, 0)?; + assert!(!Calls::::contains_key(call_hash)); + let caller2 = signatories2.remove(0); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller2); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); + }: as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call, true, 0) + verify { + let multisig = Multisigs::::get(multi_account_id, call_hash).ok_or("multisig not created")?; + assert_eq!(multisig.approvals.len(), 2); + assert!(Calls::::contains_key(call_hash)); + } + as_multi_complete { // Signatories, need at least 2 people let s in 2 .. T::MaxSignatories::get() as u32; @@ -138,6 +178,9 @@ benchmarks! { } let caller2 = signatories2.remove(0); assert!(Multisigs::::contains_key(&multi_account_id, call_hash)); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller2); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call, false, Weight::max_value()) verify { assert!(!Multisigs::::contains_key(&multi_account_id, call_hash)); @@ -146,12 +189,15 @@ benchmarks! { approve_as_multi_create { // Signatories, need at least 2 people let s in 2 .. T::MaxSignatories::get() as u32; - // Transaction Length - let z in 0 .. 10_000; + // Transaction Length, not a component + let z = 10_000; let (mut signatories, call) = setup_multi::(s, z)?; let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; let call_hash = blake2_256(&call); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); // Create the multi }: approve_as_multi(RawOrigin::Signed(caller), s as u16, signatories, None, call_hash, 0) verify { @@ -161,8 +207,8 @@ benchmarks! { approve_as_multi_approve { // Signatories, need at least 2 people let s in 2 .. T::MaxSignatories::get() as u32; - // Transaction Length - let z in 0 .. 10_000; + // Transaction Length, not a component + let z = 10_000; let (mut signatories, call) = setup_multi::(s, z)?; let mut signatories2 = signatories.clone(); let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); @@ -181,6 +227,9 @@ benchmarks! { 0 )?; let caller2 = signatories2.remove(0); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller2); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: approve_as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call_hash, 0) verify { let multisig = Multisigs::::get(multi_account_id, call_hash).ok_or("multisig not created")?; @@ -190,8 +239,8 @@ benchmarks! { approve_as_multi_complete { // Signatories, need at least 2 people let s in 2 .. T::MaxSignatories::get() as u32; - // Transaction Length - let z in 0 .. 10_000; + // Transaction Length, not a component + let z = 10_000; let (mut signatories, call) = setup_multi::(s, z)?; let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); let mut signatories2 = signatories.clone(); @@ -211,6 +260,9 @@ benchmarks! { } let caller2 = signatories2.remove(0); assert!(Multisigs::::contains_key(&multi_account_id, call_hash)); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller2); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: approve_as_multi( RawOrigin::Signed(caller2), s as u16, @@ -226,8 +278,8 @@ benchmarks! { cancel_as_multi { // Signatories, need at least 2 people let s in 2 .. T::MaxSignatories::get() as u32; - // Transaction Length - let z in 0 .. 10_000; + // Transaction Length, not a component + let z = 10_000; let (mut signatories, call) = setup_multi::(s, z)?; let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; @@ -237,30 +289,13 @@ benchmarks! { let o = RawOrigin::Signed(caller.clone()).into(); Multisig::::as_multi(o, s as u16, signatories.clone(), None, call.clone(), true, 0)?; assert!(Multisigs::::contains_key(&multi_account_id, call_hash)); + assert!(Calls::::contains_key(call_hash)); + // Whitelist caller account from further DB operations. + let caller_key = frame_system::Account::::hashed_key_for(&caller); + frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into()); }: _(RawOrigin::Signed(caller), s as u16, signatories, timepoint, call_hash) verify { assert!(!Multisigs::::contains_key(multi_account_id, call_hash)); - } - - cancel_as_multi_store { - // Signatories, need at least 2 people - let s in 2 .. T::MaxSignatories::get() as u32; - // Transaction Length - let z in 0 .. 10_000; - let (mut signatories, call) = setup_multi::(s, z)?; - let multi_account_id = Multisig::::multi_account_id(&signatories, s.try_into().unwrap()); - let caller = signatories.pop().ok_or("signatories should have len 2 or more")?; - T::Currency::make_free_balance_be(&caller, BalanceOf::::max_value()); - let call_hash = blake2_256(&call); - let timepoint = Multisig::::timepoint(); - // Create the multi - let o = RawOrigin::Signed(caller.clone()).into(); - Multisig::::as_multi(o, s as u16, signatories.clone(), None, call.clone(), true, 0)?; - assert!(Multisigs::::contains_key(&multi_account_id, call_hash)); - assert!(Calls::::contains_key(call_hash)); - }: cancel_as_multi(RawOrigin::Signed(caller), s as u16, signatories, timepoint, call_hash) - verify { - assert!(!Multisigs::::contains_key(&multi_account_id, call_hash)); assert!(!Calls::::contains_key(call_hash)); } } @@ -278,12 +313,12 @@ mod tests { assert_ok!(test_benchmark_as_multi_create::()); assert_ok!(test_benchmark_as_multi_create_store::()); assert_ok!(test_benchmark_as_multi_approve::()); + assert_ok!(test_benchmark_as_multi_approve_store::()); assert_ok!(test_benchmark_as_multi_complete::()); assert_ok!(test_benchmark_approve_as_multi_create::()); assert_ok!(test_benchmark_approve_as_multi_approve::()); assert_ok!(test_benchmark_approve_as_multi_complete::()); assert_ok!(test_benchmark_cancel_as_multi::()); - assert_ok!(test_benchmark_cancel_as_multi_store::()); }); } } diff --git a/frame/multisig/src/default_weights.rs b/frame/multisig/src/default_weights.rs new file mode 100644 index 0000000000000..19d1528d9aaa6 --- /dev/null +++ b/frame/multisig/src/default_weights.rs @@ -0,0 +1,89 @@ +// This file is part of Substrate. + +// Copyright (C) 2019-2020 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. + +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 2.0.0-rc6 + +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::weights::{Weight, constants::RocksDbWeight as DbWeight}; + +impl crate::WeightInfo for () { + fn as_multi_threshold_1(z: u32, ) -> Weight { + (17_161_000 as Weight) + .saturating_add((1_000 as Weight).saturating_mul(z as Weight)) + } + fn as_multi_create(s: u32, z: u32, ) -> Weight { + (79_857_000 as Weight) + .saturating_add((131_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((1_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn as_multi_create_store(s: u32, z: u32, ) -> Weight { + (90_218_000 as Weight) + .saturating_add((129_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((3_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(3 as Weight)) + .saturating_add(DbWeight::get().writes(2 as Weight)) + } + fn as_multi_approve(s: u32, z: u32, ) -> Weight { + (48_402_000 as Weight) + .saturating_add((132_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((1_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(1 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn as_multi_approve_store(s: u32, z: u32, ) -> Weight { + (88_390_000 as Weight) + .saturating_add((120_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((3_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(2 as Weight)) + } + fn as_multi_complete(s: u32, z: u32, ) -> Weight { + (98_960_000 as Weight) + .saturating_add((276_000 as Weight).saturating_mul(s as Weight)) + .saturating_add((6_000 as Weight).saturating_mul(z as Weight)) + .saturating_add(DbWeight::get().reads(3 as Weight)) + .saturating_add(DbWeight::get().writes(3 as Weight)) + } + fn approve_as_multi_create(s: u32, ) -> Weight { + (80_185_000 as Weight) + .saturating_add((121_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn approve_as_multi_approve(s: u32, ) -> Weight { + (48_386_000 as Weight) + .saturating_add((143_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(1 as Weight)) + .saturating_add(DbWeight::get().writes(1 as Weight)) + } + fn approve_as_multi_complete(s: u32, ) -> Weight { + (177_181_000 as Weight) + .saturating_add((273_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(3 as Weight)) + .saturating_add(DbWeight::get().writes(3 as Weight)) + } + fn cancel_as_multi(s: u32, ) -> Weight { + (126_334_000 as Weight) + .saturating_add((124_000 as Weight).saturating_mul(s as Weight)) + .saturating_add(DbWeight::get().reads(2 as Weight)) + .saturating_add(DbWeight::get().writes(2 as Weight)) + } +} diff --git a/frame/multisig/src/lib.rs b/frame/multisig/src/lib.rs index 06f91f8d0fd7b..1ce4e06a6e118 100644 --- a/frame/multisig/src/lib.rs +++ b/frame/multisig/src/lib.rs @@ -51,7 +51,7 @@ use codec::{Encode, Decode}; use sp_io::hashing::blake2_256; use frame_support::{decl_module, decl_event, decl_error, decl_storage, Parameter, ensure, RuntimeDebug}; use frame_support::{traits::{Get, ReservableCurrency, Currency}, - weights::{Weight, GetDispatchInfo, constants::{WEIGHT_PER_NANOS, WEIGHT_PER_MICROS}}, + weights::{Weight, GetDispatchInfo}, dispatch::{DispatchResultWithPostInfo, DispatchErrorWithPostInfo, PostDispatchInfo}, }; use frame_system::{self as system, ensure_signed, RawOrigin}; @@ -59,6 +59,7 @@ use sp_runtime::{DispatchError, DispatchResult, traits::{Dispatchable, Zero}}; mod tests; mod benchmarking; +mod default_weights; type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; /// Just a bunch of bytes, but they should decode to a valid `Call`. @@ -69,25 +70,12 @@ pub trait WeightInfo { fn as_multi_create(s: u32, z: u32, ) -> Weight; fn as_multi_create_store(s: u32, z: u32, ) -> Weight; fn as_multi_approve(s: u32, z: u32, ) -> Weight; + fn as_multi_approve_store(s: u32, z: u32, ) -> Weight; fn as_multi_complete(s: u32, z: u32, ) -> Weight; - fn approve_as_multi_create(s: u32, z: u32, ) -> Weight; - fn approve_as_multi_approve(s: u32, z: u32, ) -> Weight; - fn approve_as_multi_complete(s: u32, z: u32, ) -> Weight; - fn cancel_as_multi(s: u32, z: u32, ) -> Weight; - fn cancel_as_multi_store(s: u32, z: u32, ) -> Weight; -} - -impl WeightInfo for () { - fn as_multi_threshold_1(_z: u32, ) -> Weight { 1_000_000_000 } - fn as_multi_create(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn as_multi_create_store(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn as_multi_approve(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn as_multi_complete(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn approve_as_multi_create(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn approve_as_multi_approve(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn approve_as_multi_complete(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn cancel_as_multi(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } - fn cancel_as_multi_store(_s: u32, _z: u32, ) -> Weight { 1_000_000_000 } + fn approve_as_multi_create(s: u32, ) -> Weight; + fn approve_as_multi_approve(s: u32, ) -> Weight; + fn approve_as_multi_complete(s: u32, ) -> Weight; + fn cancel_as_multi(s: u32, ) -> Weight; } /// Configuration trait. @@ -209,48 +197,6 @@ decl_event! { } } -mod weight_of { - use super::*; - - /// - Base Weight: 33.72 + 0.002 * Z µs - /// - DB Weight: None - /// - Plus Call Weight - pub fn as_multi_threshold_1( - call_len: usize, - call_weight: Weight, - ) -> Weight { - (34 * WEIGHT_PER_MICROS) - .saturating_add((2 * WEIGHT_PER_NANOS).saturating_mul(call_len as Weight)) - .saturating_add(call_weight) - } - - /// - Base Weight: - /// - Create: 38.82 + 0.121 * S + .001 * Z µs - /// - Create w/ Store: 54.22 + 0.120 * S + .003 * Z µs - /// - Approve: 29.86 + 0.143 * S + .001 * Z µs - /// - Complete: 39.55 + 0.267 * S + .002 * Z µs - /// - DB Weight: - /// - Reads: Multisig Storage, [Caller Account], Calls, Depositor Account - /// - Writes: Multisig Storage, [Caller Account], Calls, Depositor Account - /// - Plus Call Weight - pub fn as_multi( - sig_len: usize, - call_len: usize, - call_weight: Weight, - calls_write: bool, - refunded: bool, - ) -> Weight { - call_weight - .saturating_add(55 * WEIGHT_PER_MICROS) - .saturating_add((250 * WEIGHT_PER_NANOS).saturating_mul(sig_len as Weight)) - .saturating_add((3 * WEIGHT_PER_NANOS).saturating_mul(call_len as Weight)) - .saturating_add(T::DbWeight::get().reads_writes(1, 1)) // Multisig read/write - .saturating_add(T::DbWeight::get().reads(1)) // Calls read - .saturating_add(T::DbWeight::get().writes(calls_write.into())) // Calls write - .saturating_add(T::DbWeight::get().reads_writes(refunded.into(), refunded.into())) // Deposit refunded - } -} - enum CallOrHash { Call(OpaqueCall, bool), Hash([u8; 32]), @@ -286,14 +232,12 @@ decl_module! { /// # /// O(Z + C) where Z is the length of the call and C its execution weight. /// ------------------------------- - /// - Base Weight: 33.72 + 0.002 * Z µs /// - DB Weight: None /// - Plus Call Weight /// # #[weight = ( - weight_of::as_multi_threshold_1::( - call.using_encoded(|c| c.len()), - call.get_dispatch_info().weight + T::WeightInfo::as_multi_threshold_1(call.using_encoded(|c| c.len() as u32)) + .saturating_add(call.get_dispatch_info().weight ), call.get_dispatch_info().class, )] @@ -314,17 +258,14 @@ decl_module! { let result = call.dispatch(RawOrigin::Signed(id).into()); result.map(|post_dispatch_info| post_dispatch_info.actual_weight - .map(|actual_weight| weight_of::as_multi_threshold_1::( - call_len, - actual_weight, - )) - .into() + .map(|actual_weight| + T::WeightInfo::as_multi_threshold_1(call_len as u32) + .saturating_add(actual_weight) + ).into() ).map_err(|err| match err.post_info.actual_weight { Some(actual_weight) => { - let weight_used = weight_of::as_multi_threshold_1::( - call_len, - actual_weight, - ); + let weight_used = T::WeightInfo::as_multi_threshold_1(call_len as u32) + .saturating_add(actual_weight); let post_info = Some(weight_used).into(); let error = err.error.into(); DispatchErrorWithPostInfo { post_info, error } @@ -374,23 +315,21 @@ decl_module! { /// deposit taken for its lifetime of /// `DepositBase + threshold * DepositFactor`. /// ------------------------------- - /// - Base Weight: - /// - Create: 41.89 + 0.118 * S + .002 * Z µs - /// - Create w/ Store: 53.57 + 0.119 * S + .003 * Z µs - /// - Approve: 31.39 + 0.136 * S + .002 * Z µs - /// - Complete: 39.94 + 0.26 * S + .002 * Z µs /// - DB Weight: /// - Reads: Multisig Storage, [Caller Account], Calls (if `store_call`) /// - Writes: Multisig Storage, [Caller Account], Calls (if `store_call`) /// - Plus Call Weight /// # - #[weight = weight_of::as_multi::( - other_signatories.len(), - call.len(), - *max_weight, - true, // assume worst case: calls write - true, // assume worst case: refunded - )] + #[weight = { + let s = other_signatories.len() as u32; + let z = call.len() as u32; + + T::WeightInfo::as_multi_create(s, z) + .max(T::WeightInfo::as_multi_create_store(s, z)) + .max(T::WeightInfo::as_multi_approve(s, z)) + .max(T::WeightInfo::as_multi_complete(s, z)) + .saturating_add(*max_weight) + }] fn as_multi(origin, threshold: u16, other_signatories: Vec, @@ -435,20 +374,18 @@ decl_module! { /// deposit taken for its lifetime of /// `DepositBase + threshold * DepositFactor`. /// ---------------------------------- - /// - Base Weight: - /// - Create: 44.71 + 0.088 * S - /// - Approve: 31.48 + 0.116 * S /// - DB Weight: /// - Read: Multisig Storage, [Caller Account] /// - Write: Multisig Storage, [Caller Account] /// # - #[weight = weight_of::as_multi::( - other_signatories.len(), - 0, // call_len is zero in this case - *max_weight, - true, // assume worst case: calls write - true, // assume worst case: refunded - )] + #[weight = { + let s = other_signatories.len() as u32; + + T::WeightInfo::approve_as_multi_create(s) + .max(T::WeightInfo::approve_as_multi_approve(s)) + .max(T::WeightInfo::approve_as_multi_complete(s)) + .saturating_add(*max_weight) + }] fn approve_as_multi(origin, threshold: u16, other_signatories: Vec, @@ -482,15 +419,11 @@ decl_module! { /// - I/O: 1 read `O(S)`, one remove. /// - Storage: removes one item. /// ---------------------------------- - /// - Base Weight: 36.07 + 0.124 * S /// - DB Weight: /// - Read: Multisig Storage, [Caller Account], Refund Account, Calls /// - Write: Multisig Storage, [Caller Account], Refund Account, Calls /// # - #[weight = T::DbWeight::get().reads_writes(3, 3) - .saturating_add(36 * WEIGHT_PER_MICROS) - .saturating_add((other_signatories.len() as Weight).saturating_mul(100 * WEIGHT_PER_NANOS)) - ] + #[weight = T::WeightInfo::cancel_as_multi(other_signatories.len() as u32)] fn cancel_as_multi(origin, threshold: u16, other_signatories: Vec, @@ -576,7 +509,7 @@ impl Module { Self::get_call(&call_hash, maybe_call.as_ref().map(|c| c.as_ref())) } else { None }; - if let Some(call) = maybe_approved_call { + if let Some((call, call_len)) = maybe_approved_call { // verify weight ensure!(call.get_dispatch_info().weight <= max_weight, Error::::WeightTooLow); @@ -590,13 +523,12 @@ impl Module { Self::deposit_event(RawEvent::MultisigExecuted( who, timepoint, id, call_hash, result.map(|_| ()).map_err(|e| e.error) )); - Ok(get_result_weight(result).map(|actual_weight| weight_of::as_multi::( - other_signatories_len, - call_len, - actual_weight, - true, // Call is removed - true, // User is refunded - )).into()) + Ok(get_result_weight(result).map(|actual_weight| + T::WeightInfo::as_multi_complete( + other_signatories_len as u32, + call_len as u32 + ).saturating_add(actual_weight) + ).into()) } else { // We cannot dispatch the call now; either it isn't available, or it is, but we // don't have threshold approvals even with our signature. @@ -620,14 +552,19 @@ impl Module { ensure!(stored, Error::::AlreadyApproved); } + let final_weight = if stored { + T::WeightInfo::as_multi_approve_store( + other_signatories_len as u32, + call_len as u32, + ) + } else { + T::WeightInfo::as_multi_approve( + other_signatories_len as u32, + call_len as u32, + ) + }; // Call is not made, so the actual weight does not include call - Ok(Some(weight_of::as_multi::( - other_signatories_len, - call_len, - 0, - stored, // Call stored? - false, // No refund - )).into()) + Ok(Some(final_weight).into()) } } else { // Not yet started; there should be no timepoint given. @@ -652,14 +589,20 @@ impl Module { approvals: vec![who.clone()], }); Self::deposit_event(RawEvent::NewMultisig(who, id, call_hash)); - // Call is not made, so we can return that weight - return Ok(Some(weight_of::as_multi::( - other_signatories_len, - call_len, - 0, - stored, // Call stored? - false, // No refund - )).into()) + + let final_weight = if stored { + T::WeightInfo::as_multi_create_store( + other_signatories_len as u32, + call_len as u32, + ) + } else { + T::WeightInfo::as_multi_create( + other_signatories_len as u32, + call_len as u32, + ) + }; + // Call is not made, so the actual weight does not include call + Ok(Some(final_weight).into()) } } @@ -683,13 +626,13 @@ impl Module { } /// Attempt to decode and return the call, provided by the user or from storage. - fn get_call(hash: &[u8; 32], maybe_known: Option<&[u8]>) -> Option<::Call> { + fn get_call(hash: &[u8; 32], maybe_known: Option<&[u8]>) -> Option<(::Call, usize)> { maybe_known.map_or_else(|| { Calls::::get(hash).and_then(|(data, ..)| { - Decode::decode(&mut &data[..]).ok() + Decode::decode(&mut &data[..]).ok().map(|d| (d, data.len())) }) }, |data| { - Decode::decode(&mut &data[..]).ok() + Decode::decode(&mut &data[..]).ok().map(|d| (d, data.len())) }) }