pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 17:01:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

on_initialize return weight consumed and default cost to default DispatchInfo instead of zero (#5382)

Browse Source 
* frame update

* doc

* move offchain worker trait also

* fix weigh merge

* indentation

* reorder for better git diff

* comment

* fix benchmark

* remove test
This commit is contained in:
thiolliere
2020-03-24 19:51:04 +01:00
committed by GitHub
parent 2e558908e6
commit 8a41ac664b
32 changed files with 331 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/bin/node/runtime/src/lib.rs
+1 -32
View File
@@ -935,6 +935,7 @@ impl_runtime_apis! {
mod tests {
use super::*;
use frame_system::offchain::{SignAndSubmitTransaction, SubmitSignedTransaction};
use frame_support::traits::OnInitialize;
#[test]
fn validate_transaction_submitter_bounds() {
@@ -958,36 +959,4 @@ mod tests {
is_submit_signed_transaction::<SubmitTransaction>();
is_sign_and_submit_transaction::<SubmitTransaction>();
}
#[test]
fn block_hooks_weight_should_not_exceed_limits() {
use frame_support::weights::WeighBlock;
let check_for_block = |b| {
let block_hooks_weight =
<AllModules as WeighBlock<BlockNumber>>::on_initialize(b) +
<AllModules as WeighBlock<BlockNumber>>::on_finalize(b);
assert_eq!(
block_hooks_weight,
0,
"This test might fail simply because the value being compared to has increased to a \
module declaring a new weight for a hook or call. In this case update the test and \
happily move on.",
);
// Invariant. Always must be like this to have a sane chain.
assert!(block_hooks_weight < MaximumBlockWeight::get());
// Warning.
if block_hooks_weight > MaximumBlockWeight::get() / 2 {
println!(
"block hooks weight is consuming more than a block's capacity. You probably want \
to re-think this. This test will fail now."
);
assert!(false);
}
};
let _ = (0..100_000).for_each(check_for_block);
}
}
substrate/frame/authorship/src/lib.rs
+4 -2
View File
@@ -27,7 +27,7 @@ use frame_support::traits::{FindAuthor, VerifySeal, Get};
use codec::{Encode, Decode};
use frame_system::ensure_none;
use sp_runtime::traits::{Header as HeaderT, One, Zero};
use frame_support::weights::SimpleDispatchInfo;
use frame_support::weights::{Weight, SimpleDispatchInfo, WeighData};
use sp_inherents::{InherentIdentifier, ProvideInherent, InherentData};
use sp_authorship::{INHERENT_IDENTIFIER, UnclesInherentData, InherentError};
@@ -185,7 +185,7 @@ decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
type Error = Error<T>;
fn on_initialize(now: T::BlockNumber) {
fn on_initialize(now: T::BlockNumber) -> Weight {
let uncle_generations = T::UncleGenerations::get();
// prune uncles that are older than the allowed number of generations.
if uncle_generations <= now {
@@ -196,6 +196,8 @@ decl_module! {
<Self as Store>::DidSetUncles::put(false);
T::EventHandler::note_author(Self::author());
SimpleDispatchInfo::default().weigh_data(())
}
fn on_finalize() {
substrate/frame/babe/src/lib.rs
+7 -2
View File
@@ -23,7 +23,10 @@
pub use pallet_timestamp;
use sp_std::{result, prelude::*};
use frame_support::{decl_storage, decl_module, traits::{FindAuthor, Get, Randomness as RandomnessT}};
use frame_support::{
decl_storage, decl_module, traits::{FindAuthor, Get, Randomness as RandomnessT},
weights::{Weight, SimpleDispatchInfo, WeighData},
};
use sp_timestamp::OnTimestampSet;
use sp_runtime::{generic::DigestItem, ConsensusEngineId, Perbill, PerThing};
use sp_runtime::traits::{IsMember, SaturatedConversion, Saturating, Hash};
@@ -171,8 +174,10 @@ decl_module! {
const ExpectedBlockTime: T::Moment = T::ExpectedBlockTime::get();
/// Initialization
fn on_initialize(now: T::BlockNumber) {
fn on_initialize(now: T::BlockNumber) -> Weight {
Self::do_initialize(now);
SimpleDispatchInfo::default().weigh_data(())
}
/// Block finalization
substrate/frame/babe/src/tests.rs
+2 -1
View File
@@ -17,8 +17,9 @@
//! Consensus extension module tests for BABE consensus.
use super::*;
use frame_support::traits::OnFinalize;
use mock::{new_test_ext, Babe, System};
use sp_runtime::{traits::OnFinalize, testing::{Digest, DigestItem}};
use sp_runtime::testing::{Digest, DigestItem};
use sp_consensus_vrf::schnorrkel::{RawVRFOutput, RawVRFProof};
use pallet_session::ShouldEndSession;
substrate/frame/democracy/src/lib.rs
+7 -3
View File
@@ -170,7 +170,7 @@ use sp_runtime::{
use codec::{Ref, Decode};
use frame_support::{
decl_module, decl_storage, decl_event, decl_error, ensure, Parameter,
weights::SimpleDispatchInfo,
weights::{SimpleDispatchInfo, Weight, WeighData},
traits::{
Currency, ReservableCurrency, LockableCurrency, WithdrawReason, LockIdentifier, Get,
OnUnbalanced, BalanceStatus
@@ -499,8 +499,10 @@ decl_module! {
fn deposit_event() = default;
fn on_runtime_upgrade() {
fn on_runtime_upgrade() -> Weight {
Self::migrate();
SimpleDispatchInfo::default().weigh_data(())
}
/// Propose a sensitive action to be taken.
@@ -813,10 +815,12 @@ decl_module! {
<DispatchQueue<T>>::put(items);
}
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
if let Err(e) = Self::begin_block(n) {
sp_runtime::print(e);
}
SimpleDispatchInfo::default().weigh_data(())
}
/// Specify a proxy that is already open to us. Called by the stash.
substrate/frame/elections-phragmen/src/lib.rs
+9 -4
View File
@@ -87,8 +87,9 @@ use sp_runtime::{
print, DispatchResult, DispatchError, Perbill, traits::{Zero, StaticLookup, Convert},
};
use frame_support::{
decl_storage, decl_event, ensure, decl_module, decl_error, weights::SimpleDispatchInfo,
storage::{StorageMap, IterableStorageMap}, traits::{
decl_storage, decl_event, ensure, decl_module, decl_error,
weights::{SimpleDispatchInfo, Weight, WeighData}, storage::{StorageMap, IterableStorageMap},
traits::{
Currency, Get, LockableCurrency, LockIdentifier, ReservableCurrency, WithdrawReasons,
ChangeMembers, OnUnbalanced, WithdrawReason, Contains, BalanceStatus
}
@@ -223,8 +224,10 @@ decl_module! {
fn deposit_event() = default;
fn on_runtime_upgrade() {
fn on_runtime_upgrade() -> Weight {
migration::migrate::<T>();
SimpleDispatchInfo::default().weigh_data(())
}
const CandidacyBond: BalanceOf<T> = T::CandidacyBond::get();
@@ -461,11 +464,13 @@ decl_module! {
}
/// What to do at the end of each block. Checks if an election needs to happen or not.
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
if let Err(e) = Self::end_block(n) {
print("Guru meditation");
print(e);
}
SimpleDispatchInfo::default().weigh_data(())
}
}
}
substrate/frame/elections/src/lib.rs
+3 -2
View File
@@ -30,7 +30,7 @@ use sp_runtime::{
};
use frame_support::{
decl_storage, decl_event, ensure, decl_module, decl_error,
weights::SimpleDispatchInfo,
weights::{Weight, SimpleDispatchInfo, WeighData},
traits::{
Currency, ExistenceRequirement, Get, LockableCurrency, LockIdentifier, BalanceStatus,
OnUnbalanced, ReservableCurrency, WithdrawReason, WithdrawReasons, ChangeMembers
@@ -698,11 +698,12 @@ decl_module! {
<TermDuration<T>>::put(count);
}
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
if let Err(e) = Self::end_block(n) {
print("Guru meditation");
print(e);
}
SimpleDispatchInfo::default().weigh_data(())
}
}
}
substrate/frame/example/src/lib.rs
+12 -6
View File
@@ -256,7 +256,10 @@
use sp_std::marker::PhantomData;
use frame_support::{
dispatch::DispatchResult, decl_module, decl_storage, decl_event,
weights::{SimpleDispatchInfo, DispatchInfo, DispatchClass, ClassifyDispatch, WeighData, Weight, PaysFee},
weights::{
SimpleDispatchInfo, DispatchInfo, DispatchClass, ClassifyDispatch, WeighData, Weight,
PaysFee,
},
};
use sp_std::prelude::*;
use frame_benchmarking::{benchmarks, account};
@@ -516,14 +519,14 @@ decl_module! {
// This function could also very well have a weight annotation, similar to any other. The
// only difference being that if it is not annotated, the default is
// `SimpleDispatchInfo::zero()`, which resolves into no weight.
#[weight = SimpleDispatchInfo::FixedNormal(1000)]
fn on_initialize(_n: T::BlockNumber) {
fn on_initialize(_n: T::BlockNumber) -> Weight {
// Anything that needs to be done at the start of the block.
// We don't do anything here.
SimpleDispatchInfo::default().weigh_data(())
}
// The signature could also look like: `fn on_finalize()`
#[weight = SimpleDispatchInfo::FixedNormal(2000)]
fn on_finalize(_n: T::BlockNumber) {
// Anything that needs to be done at the end of the block.
// We just kill our dummy storage item.
@@ -688,14 +691,17 @@ benchmarks!{
mod tests {
use super::*;
use frame_support::{assert_ok, impl_outer_origin, parameter_types, weights::GetDispatchInfo};
use frame_support::{
assert_ok, impl_outer_origin, parameter_types, weights::GetDispatchInfo,
traits::{OnInitialize, OnFinalize}
};
use sp_core::H256;
// The testing primitives are very useful for avoiding having to work with signatures
// or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.
use sp_runtime::{
Perbill,
testing::Header,
traits::{BlakeTwo256, OnInitialize, OnFinalize, IdentityLookup},
traits::{BlakeTwo256, IdentityLookup},
};
impl_outer_origin! {
substrate/frame/executive/src/lib.rs
+16 -23
View File
@@ -75,16 +75,18 @@
#![cfg_attr(not(feature = "std"), no_std)]
use sp_std::{prelude::*, marker::PhantomData};
use frame_support::{storage::StorageValue, weights::{GetDispatchInfo, WeighBlock, DispatchInfo}};
use frame_support::{
storage::StorageValue, weights::{GetDispatchInfo, DispatchInfo},
traits::{OnInitialize, OnFinalize, OnRuntimeUpgrade, OffchainWorker},
};
use sp_runtime::{
generic::Digest, ApplyExtrinsicResult,
traits::{
self, Header, Zero, One, Checkable, Applyable, CheckEqual, OnFinalize, OnInitialize,
NumberFor, Block as BlockT, OffchainWorker, Dispatchable, Saturating, OnRuntimeUpgrade,
self, Header, Zero, One, Checkable, Applyable, CheckEqual, ValidateUnsigned, NumberFor,
Block as BlockT, Dispatchable, Saturating,
},
transaction_validity::TransactionValidity,
};
use sp_runtime::traits::ValidateUnsigned;
use codec::{Codec, Encode};
use frame_system::{extrinsics_root, DigestOf};
@@ -111,8 +113,7 @@ impl<
OnRuntimeUpgrade +
OnInitialize<System::BlockNumber> +
OnFinalize<System::BlockNumber> +
OffchainWorker<System::BlockNumber> +
WeighBlock<System::BlockNumber>,
OffchainWorker<System::BlockNumber>,
> ExecuteBlock<Block> for Executive<System, Block, Context, UnsignedValidator, AllModules>
where
Block::Extrinsic: Checkable<Context> + Codec,
@@ -137,8 +138,7 @@ impl<
OnRuntimeUpgrade +
OnInitialize<System::BlockNumber> +
OnFinalize<System::BlockNumber> +
OffchainWorker<System::BlockNumber> +
WeighBlock<System::BlockNumber>,
OffchainWorker<System::BlockNumber>,
> Executive<System, Block, Context, UnsignedValidator, AllModules>
where
Block::Extrinsic: Checkable<Context> + Codec,
@@ -179,10 +179,8 @@ where
if Self::runtime_upgraded() {
// System is not part of `AllModules`, so we need to call this manually.
<frame_system::Module::<System> as OnRuntimeUpgrade>::on_runtime_upgrade();
<AllModules as OnRuntimeUpgrade>::on_runtime_upgrade();
<frame_system::Module<System>>::register_extra_weight_unchecked(
<AllModules as WeighBlock<System::BlockNumber>>::on_runtime_upgrade()
);
let weight = <AllModules as OnRuntimeUpgrade>::on_runtime_upgrade();
<frame_system::Module<System>>::register_extra_weight_unchecked(weight);
}
<frame_system::Module<System>>::initialize(
block_number,
@@ -192,13 +190,8 @@ where
frame_system::InitKind::Full,
);
<frame_system::Module<System> as OnInitialize<System::BlockNumber>>::on_initialize(*block_number);
<AllModules as OnInitialize<System::BlockNumber>>::on_initialize(*block_number);
<frame_system::Module<System>>::register_extra_weight_unchecked(
<AllModules as WeighBlock<System::BlockNumber>>::on_initialize(*block_number)
);
<frame_system::Module<System>>::register_extra_weight_unchecked(
<AllModules as WeighBlock<System::BlockNumber>>::on_finalize(*block_number)
);
let weight = <AllModules as OnInitialize<System::BlockNumber>>::on_initialize(*block_number);
<frame_system::Module<System>>::register_extra_weight_unchecked(weight);
frame_system::Module::<System>::note_finished_initialize();
}
@@ -400,7 +393,7 @@ mod tests {
use hex_literal::hex;
mod custom {
use frame_support::weights::SimpleDispatchInfo;
use frame_support::weights::{SimpleDispatchInfo, Weight};
pub trait Trait: frame_system::Trait {}
@@ -422,11 +415,11 @@ mod tests {
// module hooks.
// one with block number arg and one without
#[weight = SimpleDispatchInfo::FixedNormal(25)]
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
println!("on_initialize({})", n);
175
}
#[weight = SimpleDispatchInfo::FixedNormal(150)]
fn on_finalize() {
println!("on_finalize(?)");
}
substrate/frame/finality-tracker/src/lib.rs
+4 -2
View File
@@ -207,9 +207,11 @@ mod tests {
use sp_core::H256;
use sp_runtime::{
testing::Header, Perbill,
traits::{BlakeTwo256, IdentityLookup, OnFinalize, Header as HeaderT},
traits::{BlakeTwo256, IdentityLookup, Header as HeaderT},
};
use frame_support::{
assert_ok, impl_outer_origin, parameter_types, weights::Weight, traits::OnFinalize
};
use frame_support::{assert_ok, impl_outer_origin, parameter_types, weights::Weight};
use frame_system as system;
use std::cell::RefCell;
substrate/frame/grandpa/src/tests.rs
+2 -1
View File
@@ -18,7 +18,8 @@
#![cfg(test)]
use sp_runtime::{testing::{H256, Digest}, traits::{Header, OnFinalize}};
use sp_runtime::{testing::{H256, Digest}, traits::Header};
use frame_support::traits::OnFinalize;
use crate::mock::*;
use frame_system::{EventRecord, Phase};
use codec::{Decode, Encode};
substrate/frame/im-online/src/tests.rs
+1 -1
View File
@@ -190,7 +190,7 @@ fn late_heartbeat_should_fail() {
#[test]
fn should_generate_heartbeats() {
use sp_runtime::traits::OffchainWorker;
use frame_support::traits::OffchainWorker;
let mut ext = new_test_ext();
let (offchain, _state) = TestOffchainExt::new();
substrate/frame/indices/src/lib.rs
+4 -1
View File
@@ -25,6 +25,7 @@ use sp_runtime::traits::{
StaticLookup, Member, LookupError, Zero, One, BlakeTwo256, Hash, Saturating, AtLeast32Bit
};
use frame_support::{Parameter, decl_module, decl_error, decl_event, decl_storage, ensure};
use frame_support::weights::{Weight, SimpleDispatchInfo, WeighData};
use frame_support::dispatch::DispatchResult;
use frame_support::traits::{Currency, ReservableCurrency, Get, BalanceStatus::Reserved};
use frame_support::storage::migration::take_storage_value;
@@ -98,8 +99,10 @@ decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin, system = frame_system {
fn deposit_event() = default;
fn on_initialize() {
fn on_initialize() -> Weight {
Self::migrations();
SimpleDispatchInfo::default().weigh_data(())
}
/// Assign an previously unassigned index.
substrate/frame/offences/src/lib.rs
+4 -1
View File
@@ -27,6 +27,7 @@ mod tests;
use sp_std::vec::Vec;
use frame_support::{
decl_module, decl_event, decl_storage, Parameter,
weights::{Weight, SimpleDispatchInfo, WeighData},
};
use sp_runtime::traits::Hash;
use sp_staking::{
@@ -86,10 +87,12 @@ decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
fn deposit_event() = default;
fn on_runtime_upgrade() {
fn on_runtime_upgrade() -> Weight {
Reports::<T>::remove_all();
ConcurrentReportsIndex::<T>::remove_all();
ReportsByKindIndex::remove_all();
SimpleDispatchInfo::default().weigh_data(())
}
}
}
substrate/frame/randomness-collective-flip/src/lib.rs
+11 -4
View File
@@ -54,7 +54,10 @@
use sp_std::{prelude::*, convert::TryInto};
use sp_runtime::traits::Hash;
use frame_support::{decl_module, decl_storage, traits::Randomness};
use frame_support::{
decl_module, decl_storage, traits::Randomness,
weights::{Weight, SimpleDispatchInfo, WeighData}
};
use safe_mix::TripletMix;
use codec::Encode;
use frame_system::Trait;
@@ -69,7 +72,7 @@ fn block_number_to_index<T: Trait>(block_number: T::BlockNumber) -> usize {
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
fn on_initialize(block_number: T::BlockNumber) {
fn on_initialize(block_number: T::BlockNumber) -> Weight {
let parent_hash = <frame_system::Module<T>>::parent_hash();
<RandomMaterial<T>>::mutate(|ref mut values| if values.len() < RANDOM_MATERIAL_LEN as usize {
@@ -78,6 +81,8 @@ decl_module! {
let index = block_number_to_index::<T>(block_number);
values[index] = parent_hash;
});
SimpleDispatchInfo::default().weigh_data(())
}
}
}
@@ -156,9 +161,11 @@ mod tests {
use sp_runtime::{
Perbill,
testing::Header,
traits::{BlakeTwo256, OnInitialize, Header as _, IdentityLookup},
traits::{BlakeTwo256, Header as _, IdentityLookup},
};
use frame_support::{
impl_outer_origin, parameter_types, weights::Weight, traits::{Randomness, OnInitialize},
};
use frame_support::{impl_outer_origin, parameter_types, weights::Weight, traits::Randomness};
#[derive(Clone, PartialEq, Eq)]
pub struct Test;
substrate/frame/recovery/src/mock.rs
+2 -1
View File
@@ -21,12 +21,13 @@ use super::*;
use frame_support::{
impl_outer_origin, impl_outer_dispatch, impl_outer_event, parameter_types,
weights::Weight,
traits::{OnInitialize, OnFinalize},
};
use sp_core::H256;
// The testing primitives are very useful for avoiding having to work with signatures
// or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.
use sp_runtime::{
Perbill, traits::{BlakeTwo256, IdentityLookup, OnInitialize, OnFinalize}, testing::Header,
Perbill, traits::{BlakeTwo256, IdentityLookup}, testing::Header,
};
use crate as recovery;
substrate/frame/scored-pool/src/lib.rs
+3 -1
View File
@@ -96,6 +96,7 @@ use sp_std::{
use frame_support::{
decl_module, decl_storage, decl_event, ensure, decl_error,
traits::{ChangeMembers, InitializeMembers, Currency, Get, ReservableCurrency},
weights::{Weight, SimpleDispatchInfo, WeighData},
};
use frame_system::{self as system, ensure_root, ensure_signed};
use sp_runtime::{
@@ -245,11 +246,12 @@ decl_module! {
/// Every `Period` blocks the `Members` set is refreshed from the
/// highest scoring members in the pool.
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
if n % T::Period::get() == Zero::zero() {
let pool = <Pool<T, I>>::get();
<Module<T, I>>::refresh_members(pool, ChangeReceiver::MembershipChanged);
}
SimpleDispatchInfo::default().weigh_data(())
}
/// Add `origin` to the pool of candidates.
substrate/frame/scored-pool/src/tests.rs
+2 -2
View File
@@ -19,8 +19,8 @@
use super::*;
use mock::*;
use frame_support::{assert_ok, assert_noop};
use sp_runtime::traits::{OnInitialize, BadOrigin};
use frame_support::{assert_ok, assert_noop, traits::OnInitialize};
use sp_runtime::traits::BadOrigin;
type ScoredPool = Module<Test>;
type System = frame_system::Module<Test>;
substrate/frame/session/src/historical.rs
+2 -2
View File
@@ -310,12 +310,12 @@ impl<T: Trait, D: AsRef<[u8]>> frame_support::traits::KeyOwnerProofSystem<(KeyTy
mod tests {
use super::*;
use sp_core::crypto::key_types::DUMMY;
use sp_runtime::{traits::OnInitialize, testing::UintAuthorityId};
use sp_runtime::testing::UintAuthorityId;
use crate::mock::{
NEXT_VALIDATORS, force_new_session,
set_next_validators, Test, System, Session,
};
use frame_support::traits::KeyOwnerProofSystem;
use frame_support::traits::{KeyOwnerProofSystem, OnInitialize};
type Historical = Module<Test>;
substrate/frame/session/src/lib.rs
+9 -5
View File
@@ -102,12 +102,14 @@
use sp_std::{prelude::*, marker::PhantomData, ops::{Sub, Rem}};
use codec::Decode;
use sp_runtime::{KeyTypeId, Perbill, RuntimeAppPublic, BoundToRuntimeAppPublic};
use frame_support::weights::SimpleDispatchInfo;
use sp_runtime::traits::{Convert, Zero, Member, OpaqueKeys};
use sp_staking::SessionIndex;
use frame_support::{ensure, decl_module, decl_event, decl_storage, decl_error, ConsensusEngineId};
use frame_support::{traits::{Get, FindAuthor, ValidatorRegistration}, Parameter};
use frame_support::dispatch::{self, DispatchResult, DispatchError};
use frame_support::{
ensure, decl_module, decl_event, decl_storage, decl_error, ConsensusEngineId, Parameter,
weights::{Weight, SimpleDispatchInfo, WeighData},
traits::{Get, FindAuthor, ValidatorRegistration},
dispatch::{self, DispatchResult, DispatchError},
};
use frame_system::{self as system, ensure_signed};
#[cfg(test)]
@@ -495,10 +497,12 @@ decl_module! {
/// Called when a block is initialized. Will rotate session if it is the last
/// block of the current session.
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
if T::ShouldEndSession::should_end_session(n) {
Self::rotate_session();
}
SimpleDispatchInfo::default().weigh_data(())
}
}
}
substrate/frame/session/src/tests.rs
+2 -2
View File
@@ -17,9 +17,9 @@
// Tests for the Session Pallet
use super::*;
use frame_support::assert_ok;
use frame_support::{traits::OnInitialize, assert_ok};
use sp_core::crypto::key_types::DUMMY;
use sp_runtime::{traits::OnInitialize, testing::UintAuthorityId};
use sp_runtime::testing::UintAuthorityId;
use mock::{
NEXT_VALIDATORS, SESSION_CHANGED, TEST_SESSION_CHANGED, authorities, force_new_session,
set_next_validators, set_session_length, session_changed, Test, Origin, System, Session,
substrate/frame/society/src/lib.rs
+4 -2
View File
@@ -260,7 +260,7 @@ use sp_runtime::{Percent, ModuleId, RuntimeDebug,
}
};
use frame_support::{decl_error, decl_module, decl_storage, decl_event, ensure, dispatch::DispatchResult};
use frame_support::weights::SimpleDispatchInfo;
use frame_support::weights::{SimpleDispatchInfo, Weight, WeighData};
use frame_support::traits::{
Currency, ReservableCurrency, Randomness, Get, ChangeMembers, BalanceStatus,
ExistenceRequirement::AllowDeath
@@ -1028,7 +1028,7 @@ decl_module! {
Self::deposit_event(RawEvent::NewMaxMembers(max));
}
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
let mut members = vec![];
// Run a candidate/membership rotation
@@ -1045,6 +1045,8 @@ decl_module! {
}
Self::rotate_challenge(&mut members);
}
SimpleDispatchInfo::default().weigh_data(())
}
}
}
substrate/frame/society/src/mock.rs
+4 -2
View File
@@ -18,14 +18,16 @@
use super::*;
use frame_support::{impl_outer_origin, parameter_types, ord_parameter_types};
use frame_support::{
impl_outer_origin, parameter_types, ord_parameter_types, traits::{OnInitialize, OnFinalize}
};
use sp_core::H256;
// The testing primitives are very useful for avoiding having to work with signatures
// or public keys. `u64` is used as the `AccountId` and no `Signature`s are required.
use sp_runtime::{
Perbill,
testing::Header,
traits::{BlakeTwo256, IdentityLookup, OnInitialize, OnFinalize},
traits::{BlakeTwo256, IdentityLookup},
};
use frame_system::EnsureSignedBy;
substrate/frame/staking/src/mock.rs
+3 -2
View File
@@ -19,14 +19,15 @@
use std::{collections::{HashSet, HashMap}, cell::RefCell};
use sp_runtime::{Perbill, KeyTypeId};
use sp_runtime::curve::PiecewiseLinear;
use sp_runtime::traits::{IdentityLookup, Convert, OpaqueKeys, OnInitialize, OnFinalize, SaturatedConversion};
use sp_runtime::traits::{IdentityLookup, Convert, OpaqueKeys, SaturatedConversion};
use sp_runtime::testing::{Header, UintAuthorityId};
use sp_staking::{SessionIndex, offence::{OffenceDetails, OnOffenceHandler}};
use sp_core::{H256, crypto::key_types};
use sp_io;
use frame_support::{
assert_ok, impl_outer_origin, parameter_types, StorageValue, StorageMap,
StorageDoubleMap, IterableStorageMap, traits::{Currency, Get, FindAuthor}, weights::Weight,
StorageDoubleMap, IterableStorageMap,
traits::{Currency, Get, FindAuthor, OnFinalize, OnInitialize}, weights::Weight,
};
use crate::{
EraIndex, GenesisConfig, Module, Trait, StakerStatus, ValidatorPrefs, RewardDestination,
substrate/frame/staking/src/tests.rs
+2 -2
View File
@@ -18,11 +18,11 @@
use super::*;
use mock::*;
use sp_runtime::{assert_eq_error_rate, traits::{OnInitialize, BadOrigin}};
use sp_runtime::{assert_eq_error_rate, traits::BadOrigin};
use sp_staking::offence::OffenceDetails;
use frame_support::{
assert_ok, assert_noop,
traits::{Currency, ReservableCurrency},
traits::{Currency, ReservableCurrency, OnInitialize},
StorageMap,
};
use pallet_balances::Error as BalancesError;
substrate/frame/support/src/dispatch.rs
+109 -165
View File
@@ -25,7 +25,7 @@ pub use frame_metadata::{
};
pub use crate::weights::{
SimpleDispatchInfo, GetDispatchInfo, DispatchInfo, WeighData, ClassifyDispatch,
TransactionPriority, Weight, WeighBlock, PaysFee,
TransactionPriority, Weight, PaysFee,
};
pub use sp_runtime::{traits::Dispatchable, DispatchError, DispatchResult};
pub use crate::traits::{CallMetadata, GetCallMetadata, GetCallName};
@@ -200,13 +200,23 @@ impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug {}
/// is a runtime upgrade. This allows each module to upgrade its storage before the storage items are used.
/// As such, **calling other modules must be avoided**!! Using this function will implement the
/// [`OnRuntimeUpgrade`](../sp_runtime/traits/trait.OnRuntimeUpgrade.html) trait.
/// Function signature must be `fn on_runtime_upgrade() -> frame_support::weights::Weight`.
///
/// * `on_initialize`: Executes at the beginning of a block. Using this function will
/// implement the [`OnInitialize`](../sp_runtime/traits/trait.OnInitialize.html) trait.
/// implement the [`OnInitialize`](./trait.OnInitialize.html) trait.
/// Function signature can be either:
/// * `fn on_initialize(n: BlockNumber) -> frame_support::weights::Weight` or
/// * `fn on_initialize() -> frame_support::weights::Weight`
///
/// * `on_finalize`: Executes at the end of a block. Using this function will
/// implement the [`OnFinalize`](../sp_runtime/traits/trait.OnFinalize.html) trait.
/// implement the [`OnFinalize`](./traits/trait.OnFinalize.html) trait.
/// Function signature can be either:
/// * `fn on_finalize(n: BlockNumber) -> frame_support::weights::Weight` or
/// * `fn on_finalize() -> frame_support::weights::Weight`
///
/// * `offchain_worker`: Executes at the beginning of a block and produces extrinsics for a future block
/// upon completion. Using this function will implement the
/// [`OffchainWorker`](../sp_runtime/traits/trait.OffchainWorker.html) trait.
/// [`OffchainWorker`](./traits/trait.OffchainWorker.html) trait.
#[macro_export]
macro_rules! decl_module {
// Entry point #1.
@@ -327,7 +337,7 @@ macro_rules! decl_module {
"`deposit_event` function is reserved and must follow the syntax: `$vis:vis fn deposit_event() = default;`"
);
};
// Add on_finalize, without a given weight.
// Add on_finalize
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<$trait_instance:ident: $trait_name:ident$(<I>, I: $instantiable:path $(= $module_default_instance:path)?)?>
@@ -354,7 +364,6 @@ macro_rules! decl_module {
{ $( $on_initialize )* }
{ $( $on_runtime_upgrade )* }
{
#[weight = $crate::dispatch::SimpleDispatchInfo::zero()]
fn on_finalize( $( $param_name : $param ),* ) { $( $impl )* }
}
{ $( $offchain )* }
@@ -364,7 +373,7 @@ macro_rules! decl_module {
$($rest)*
);
};
// Add on_finalize, given weight.
// compile_error on_finalize, given weight removed syntax.
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<$trait_instance:ident: $trait_name:ident$(<I>, I: $instantiable:path $(= $module_default_instance:path)?)?>
@@ -383,26 +392,12 @@ macro_rules! decl_module {
fn on_finalize( $( $param_name:ident : $param:ty ),* $(,)? ) { $( $impl:tt )* }
$($rest:tt)*
) => {
$crate::decl_module!(@normalize
$(#[$attr])*
pub struct $mod_type<$trait_instance: $trait_name$(<I>, I: $instantiable $(= $module_default_instance)?)?>
for enum $call_type where origin: $origin_type, system = $system
{ $( $other_where_bounds )* }
{ $( $deposit_event )* }
{ $( $on_initialize )* }
{ $( $on_runtime_upgrade )* }
{
#[weight = $weight]
fn on_finalize( $( $param_name : $param ),* ) { $( $impl )* }
}
{ $( $offchain )* }
{ $( $constants )* }
{ $( $error_type )* }
[ $( $dispatchables )* ]
$($rest)*
compile_error!(
"`on_finalize` can't be given weight attribute anymore, weight must be returned by \
`on_initialize` or `on_runtime_upgrade` instead"
);
};
// Add on_runtime_upgrade, without a given weight.
// compile_error on_runtime_upgrade, without a given weight removed syntax.
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<
@@ -422,26 +417,11 @@ macro_rules! decl_module {
fn on_runtime_upgrade( $( $param_name:ident : $param:ty ),* $(,)? ) { $( $impl:tt )* }
$($rest:tt)*
) => {
$crate::decl_module!(@normalize
$(#[$attr])*
pub struct $mod_type<$trait_instance: $trait_name$(<I>, I: $instantiable $(= $module_default_instance)?)?>
for enum $call_type where origin: $origin_type, system = $system
{ $( $other_where_bounds )* }
{ $( $deposit_event )* }
{ $( $on_initialize )* }
{
#[weight = $crate::dispatch::SimpleDispatchInfo::zero()]
fn on_runtime_upgrade( $( $param_name : $param ),* ) { $( $impl )* }
}
{ $( $on_finalize )* }
{ $( $offchain )* }
{ $( $constants )* }
{ $( $error_type )* }
[ $( $dispatchables )* ]
$($rest)*
compile_error!(
"`on_runtime_upgrade` must return Weight, signature has changed."
);
};
// Add on_runtime_upgrade, given weight.
// compile_error on_runtime_upgrade, given weight removed syntax.
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<
@@ -461,6 +441,31 @@ macro_rules! decl_module {
#[weight = $weight:expr]
fn on_runtime_upgrade( $( $param_name:ident : $param:ty ),* $(,)? ) { $( $impl:tt )* }
$($rest:tt)*
) => {
compile_error!(
"`on_runtime_upgrade` can't be given weight attribute anymore, weight must be returned \
by the function directly."
);
};
// Add on_runtime_upgrade
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<
$trait_instance:ident: $trait_name:ident$(<I>, I: $instantiable:path $(= $module_default_instance:path)?)?
>
for enum $call_type:ident where origin: $origin_type:ty, system = $system:ident
{ $( $other_where_bounds:tt )* }
{ $( $deposit_event:tt )* }
{ $( $on_initialize:tt )* }
{}
{ $( $on_finalize:tt )* }
{ $( $offchain:tt )* }
{ $( $constants:tt )* }
{ $( $error_type:tt )* }
[ $( $dispatchables:tt )* ]
$(#[doc = $doc_attr:tt])*
fn on_runtime_upgrade( $( $param_name:ident : $param:ty ),* $(,)? ) -> $return:ty { $( $impl:tt )* }
$($rest:tt)*
) => {
$crate::decl_module!(@normalize
$(#[$attr])*
@@ -470,8 +475,7 @@ macro_rules! decl_module {
{ $( $deposit_event )* }
{ $( $on_initialize )* }
{
#[weight = $weight]
fn on_runtime_upgrade( $( $param_name : $param ),* ) { $( $impl )* }
fn on_runtime_upgrade( $( $param_name : $param ),* ) -> $return { $( $impl )* }
}
{ $( $on_finalize )* }
{ $( $offchain )* }
@@ -481,7 +485,7 @@ macro_rules! decl_module {
$($rest)*
);
};
// Add on_initialize, without a given weight.
// compile_error on_initialize, without a given weight removed syntax.
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<
@@ -501,26 +505,11 @@ macro_rules! decl_module {
fn on_initialize( $( $param_name:ident : $param:ty ),* $(,)? ) { $( $impl:tt )* }
$($rest:tt)*
) => {
$crate::decl_module!(@normalize
$(#[$attr])*
pub struct $mod_type<$trait_instance: $trait_name$(<I>, I: $instantiable $(= $module_default_instance)?)?>
for enum $call_type where origin: $origin_type, system = $system
{ $( $other_where_bounds )* }
{ $( $deposit_event )* }
{
#[weight = $crate::dispatch::SimpleDispatchInfo::zero()]
fn on_initialize( $( $param_name : $param ),* ) { $( $impl )* }
}
{ $( $on_runtime_upgrade )* }
{ $( $on_finalize )* }
{ $( $offchain )* }
{ $( $constants )* }
{ $( $error_type )* }
[ $( $dispatchables )* ]
$($rest)*
compile_error!(
"`on_initialize` must return Weight, signature has changed."
);
};
// Add on_initialize, given weight.
// compile_error on_initialize, with given weight removed syntax.
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<
@@ -540,6 +529,31 @@ macro_rules! decl_module {
#[weight = $weight:expr]
fn on_initialize( $( $param_name:ident : $param:ty ),* $(,)? ) { $( $impl:tt )* }
$($rest:tt)*
) => {
compile_error!(
"`on_initialize` can't be given weight attribute anymore, weight must be returned \
by the function directly."
);
};
// Add on_initialize
(@normalize
$(#[$attr:meta])*
pub struct $mod_type:ident<
$trait_instance:ident: $trait_name:ident$(<I>, I: $instantiable:path $(= $module_default_instance:path)?)?
>
for enum $call_type:ident where origin: $origin_type:ty, system = $system:ident
{ $( $other_where_bounds:tt )* }
{ $( $deposit_event:tt )* }
{}
{ $( $on_runtime_upgrade:tt )* }
{ $( $on_finalize:tt )* }
{ $( $offchain:tt )* }
{ $( $constants:tt )* }
{ $( $error_type:tt )* }
[ $( $dispatchables:tt )* ]
$(#[doc = $doc_attr:tt])*
fn on_initialize( $( $param_name:ident : $param:ty ),* $(,)? ) -> $return:ty { $( $impl:tt )* }
$($rest:tt)*
) => {
$crate::decl_module!(@normalize
$(#[$attr])*
@@ -548,8 +562,7 @@ macro_rules! decl_module {
{ $( $other_where_bounds )* }
{ $( $deposit_event )* }
{
#[weight = $weight]
fn on_initialize( $( $param_name : $param ),* ) { $( $impl )* }
fn on_initialize( $( $param_name : $param ),* ) -> $return { $( $impl )* }
}
{ $( $on_runtime_upgrade )* }
{ $( $on_finalize )* }
@@ -965,14 +978,13 @@ macro_rules! decl_module {
(@impl_on_initialize
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
#[weight = $weight:expr]
fn on_initialize() { $( $impl:tt )* }
fn on_initialize() -> $return:ty { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnInitialize<$trait_instance::BlockNumber>
$crate::traits::OnInitialize<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn on_initialize(_block_number_not_used: $trait_instance::BlockNumber) {
fn on_initialize(_block_number_not_used: $trait_instance::BlockNumber) -> $return {
use $crate::sp_std::if_std;
if_std! {
use $crate::tracing;
@@ -987,14 +999,13 @@ macro_rules! decl_module {
(@impl_on_initialize
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
#[weight = $weight:expr]
fn on_initialize($param:ident : $param_ty:ty) { $( $impl:tt )* }
fn on_initialize($param:ident : $param_ty:ty) -> $return:ty { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnInitialize<$trait_instance::BlockNumber>
$crate::traits::OnInitialize<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn on_initialize($param: $param_ty) {
fn on_initialize($param: $param_ty) -> $return {
use $crate::sp_std::if_std;
if_std! {
use $crate::tracing;
@@ -1011,7 +1022,7 @@ macro_rules! decl_module {
{ $( $other_where_bounds:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnInitialize<$trait_instance::BlockNumber>
$crate::traits::OnInitialize<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{}
};
@@ -1019,14 +1030,13 @@ macro_rules! decl_module {
(@impl_on_runtime_upgrade
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
#[weight = $weight:expr]
fn on_runtime_upgrade() { $( $impl:tt )* }
fn on_runtime_upgrade() -> $return:ty { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnRuntimeUpgrade
$crate::traits::OnRuntimeUpgrade
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn on_runtime_upgrade() {
fn on_runtime_upgrade() -> $return {
use $crate::sp_std::if_std;
if_std! {
use $crate::tracing;
@@ -1043,7 +1053,7 @@ macro_rules! decl_module {
{ $( $other_where_bounds:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnRuntimeUpgrade
$crate::traits::OnRuntimeUpgrade
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{}
};
@@ -1052,11 +1062,10 @@ macro_rules! decl_module {
(@impl_on_finalize
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
#[weight = $weight:expr]
fn on_finalize() { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnFinalize<$trait_instance::BlockNumber>
$crate::traits::OnFinalize<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn on_finalize(_block_number_not_used: $trait_instance::BlockNumber) {
@@ -1074,11 +1083,10 @@ macro_rules! decl_module {
(@impl_on_finalize
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
#[weight = $weight:expr]
fn on_finalize($param:ident : $param_ty:ty) { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnFinalize<$trait_instance::BlockNumber>
$crate::traits::OnFinalize<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn on_finalize($param: $param_ty) {
@@ -1098,57 +1106,19 @@ macro_rules! decl_module {
{ $( $other_where_bounds:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OnFinalize<$trait_instance::BlockNumber>
$crate::traits::OnFinalize<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
}
};
(@impl_block_hooks_weight
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
@runtime_upgrade $(
#[weight = $weight_runtime_update:expr]
fn on_runtime_upgrade($( $param_runtime_upgrade:ident : $param_ty_runtime_upgrade:ty )*) { $( $impl_runtime_upgrade:tt )* }
)?
@init $(
#[weight = $weight_initialize:expr]
fn on_initialize($( $param_initialize:ident : $param_ty_initialize:ty )*) { $( $impl_initialize:tt )* }
)?
@fin $(
#[weight = $weight_finalize:expr]
fn on_finalize($( $param_finalize:ident : $param_ty_finalize:ty )*) { $( $impl_finalize:tt )* }
)?
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::dispatch::WeighBlock<$trait_instance::BlockNumber> for $module<$trait_instance$(, $instance)?> where
$( $other_where_bounds )*
{
$(
fn on_runtime_upgrade() -> $crate::dispatch::Weight {
<dyn $crate::dispatch::WeighData<()>>::weigh_data(&$weight_initialize, ())
}
)?
$(
fn on_initialize(n: $trait_instance::BlockNumber) -> $crate::dispatch::Weight {
<dyn $crate::dispatch::WeighData<$trait_instance::BlockNumber>>::weigh_data(&$weight_initialize, n)
}
)?
$(
fn on_finalize(n: $trait_instance::BlockNumber) -> $crate::dispatch::Weight {
<dyn $crate::dispatch::WeighData<$trait_instance::BlockNumber>>::weigh_data(&$weight_finalize, n)
}
)?
}
};
(@impl_offchain
$module:ident<$trait_instance:ident: $trait_name:ident$(<I>, $instance:ident: $instantiable:path)?>;
{ $( $other_where_bounds:tt )* }
fn offchain_worker() { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OffchainWorker<$trait_instance::BlockNumber>
$crate::traits::OffchainWorker<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn offchain_worker(_block_number_not_used: $trait_instance::BlockNumber) { $( $impl )* }
@@ -1161,7 +1131,7 @@ macro_rules! decl_module {
fn offchain_worker($param:ident : $param_ty:ty) { $( $impl:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OffchainWorker<$trait_instance::BlockNumber>
$crate::traits::OffchainWorker<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{
fn offchain_worker($param: $param_ty) { $( $impl )* }
@@ -1173,7 +1143,7 @@ macro_rules! decl_module {
{ $( $other_where_bounds:tt )* }
) => {
impl<$trait_instance: $trait_name$(<I>, $instance: $instantiable)?>
$crate::sp_runtime::traits::OffchainWorker<$trait_instance::BlockNumber>
$crate::traits::OffchainWorker<$trait_instance::BlockNumber>
for $module<$trait_instance$(, $instance)?> where $( $other_where_bounds )*
{}
};
@@ -1402,15 +1372,6 @@ macro_rules! decl_module {
$( $on_finalize )*
}
$crate::decl_module! {
@impl_block_hooks_weight
$mod_type<$trait_instance: $trait_name $(<I>, $instance: $instantiable)?>;
{ $( $other_where_bounds )* }
@runtime_upgrade $( $on_runtime_upgrade )*
@init $( $on_initialize )*
@fin $( $on_finalize )*
}
$crate::decl_module! {
@impl_offchain
$mod_type<$trait_instance: $trait_name $(<I>, $instance: $instantiable)?>;
@@ -2076,9 +2037,10 @@ macro_rules! __check_reserved_fn_name {
#[allow(dead_code)]
mod tests {
use super::*;
use crate::sp_runtime::traits::{OnInitialize, OnFinalize, OnRuntimeUpgrade};
use crate::weights::{DispatchInfo, DispatchClass};
use crate::traits::{CallMetadata, GetCallMetadata, GetCallName};
use crate::traits::{
CallMetadata, GetCallMetadata, GetCallName, OnInitialize, OnFinalize, OnRuntimeUpgrade
};
pub trait Trait: system::Trait + Sized where Self::AccountId: From<u32> {
type Origin;
@@ -2098,14 +2060,6 @@ mod tests {
}
}
struct BlockWeight;
impl<BlockNumber: Into<u32>> WeighData<BlockNumber> for BlockWeight {
fn weigh_data(&self, target: BlockNumber) -> Weight {
let target: u32 = target.into();
if target % 2 == 0 { 10 } else { 0 }
}
}
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin, T::AccountId: From<u32> {
/// Hi, this is a comment.
@@ -2117,12 +2071,9 @@ mod tests {
fn aux_4(_origin, _data: i32) -> DispatchResult { unreachable!() }
fn aux_5(_origin, _data: i32, #[compact] _data2: u32,) -> DispatchResult { unreachable!() }
#[weight = SimpleDispatchInfo::FixedNormal(7)]
fn on_initialize(n: T::BlockNumber,) { if n.into() == 42 { panic!("on_initialize") } }
#[weight = BlockWeight]
fn on_finalize(n: T::BlockNumber) { if n.into() == 42 { panic!("on_finalize") } }
#[weight = SimpleDispatchInfo::FixedOperational(69)]
fn on_runtime_upgrade() { }
fn on_initialize(n: T::BlockNumber,) -> Weight { if n.into() == 42 { panic!("on_initialize") } 7 }
fn on_finalize(n: T::BlockNumber,) { if n.into() == 42 { panic!("on_finalize") } }
fn on_runtime_upgrade() -> Weight { 10 }
fn offchain_worker() {}
#[weight = SimpleDispatchInfo::FixedOperational(5)]
@@ -2254,10 +2205,15 @@ mod tests {
#[test]
#[should_panic(expected = "on_initialize")]
fn on_initialize_should_work() {
fn on_initialize_should_work_1() {
<Module<TraitImpl> as OnInitialize<u32>>::on_initialize(42);
}
#[test]
fn on_initialize_should_work_2() {
assert_eq!(<Module<TraitImpl> as OnInitialize<u32>>::on_initialize(10), 7);
}
#[test]
#[should_panic(expected = "on_finalize")]
fn on_finalize_should_work() {
@@ -2266,7 +2222,7 @@ mod tests {
#[test]
fn on_runtime_upgrade_should_work() {
<Module<TraitImpl> as OnRuntimeUpgrade>::on_runtime_upgrade();
assert_eq!(<Module<TraitImpl> as OnRuntimeUpgrade>::on_runtime_upgrade(), 10);
}
#[test]
@@ -2288,18 +2244,6 @@ mod tests {
);
}
#[test]
fn weight_for_block_hooks() {
// independent of block number
assert_eq!(<Test as WeighBlock<u32>>::on_initialize(0), 7);
assert_eq!(<Test as WeighBlock<u32>>::on_initialize(10), 7);
assert_eq!(<Test as WeighBlock<u32>>::on_initialize(100), 7);
// dependent
assert_eq!(<Test as WeighBlock<u32>>::on_finalize(2), 10);
assert_eq!(<Test as WeighBlock<u32>>::on_finalize(3), 0);
}
#[test]
fn call_name() {
let name = Call::<TraitImpl>::aux_3().get_call_name();
substrate/frame/support/src/traits.rs
+91 -2
View File
@@ -28,6 +28,7 @@ use sp_runtime::{
};
use crate::dispatch::Parameter;
use crate::storage::StorageMap;
use impl_trait_for_tuples::impl_for_tuples;
/// An abstraction of a value stored within storage, but possibly as part of a larger composite
/// item.
@@ -193,14 +194,14 @@ impl<AccountId> IsDeadAccount<AccountId> for () {
}
/// Handler for when a new account has been created.
#[impl_trait_for_tuples::impl_for_tuples(30)]
#[impl_for_tuples(30)]
pub trait OnNewAccount<AccountId> {
/// A new account `who` has been registered.
fn on_new_account(who: &AccountId);
}
/// The account with the given id was reaped.
#[impl_trait_for_tuples::impl_for_tuples(30)]
#[impl_for_tuples(30)]
pub trait OnKilledAccount<AccountId> {
/// The account with the given id was reaped.
fn on_killed_account(who: &AccountId);
@@ -1042,3 +1043,91 @@ pub trait GetCallMetadata {
/// Return a [`CallMetadata`], containing function and pallet name of the Call.
fn get_call_metadata(&self) -> CallMetadata;
}
/// The block finalization trait. Implementing this lets you express what should happen
/// for your module when the block is ending.
#[impl_for_tuples(30)]
pub trait OnFinalize<BlockNumber> {
/// The block is being finalized. Implement to have something happen.
fn on_finalize(_n: BlockNumber) {}
}
/// The block initialization trait. Implementing this lets you express what should happen
/// for your module when the block is beginning (right before the first extrinsic is executed).
pub trait OnInitialize<BlockNumber> {
/// The block is being initialized. Implement to have something happen.
///
/// Return the non-negotiable weight consumed in the block.
fn on_initialize(_n: BlockNumber) -> crate::weights::Weight { 0 }
}
#[impl_for_tuples(30)]
impl<BlockNumber: Clone> OnInitialize<BlockNumber> for Tuple {
fn on_initialize(_n: BlockNumber) -> crate::weights::Weight {
let mut weight = 0;
for_tuples!( #( weight = weight.saturating_add(Tuple::on_initialize(_n.clone())); )* );
weight
}
}
/// The runtime upgrade trait. Implementing this lets you express what should happen
/// when the runtime upgrades, and changes may need to occur to your module.
pub trait OnRuntimeUpgrade {
/// Perform a module upgrade.
///
/// Return the non-negotiable weight consumed for runtime upgrade.
fn on_runtime_upgrade() -> crate::weights::Weight { 0 }
}
#[impl_for_tuples(30)]
impl OnRuntimeUpgrade for Tuple {
fn on_runtime_upgrade() -> crate::weights::Weight {
let mut weight = 0;
for_tuples!( #( weight = weight.saturating_add(Tuple::on_runtime_upgrade()); )* );
weight
}
}
/// Off-chain computation trait.
///
/// Implementing this trait on a module allows you to perform long-running tasks
/// that make (by default) validators generate transactions that feed results
/// of those long-running computations back on chain.
///
/// NOTE: This function runs off-chain, so it can access the block state,
/// but cannot preform any alterations. More specifically alterations are
/// not forbidden, but they are not persisted in any way after the worker
/// has finished.
#[impl_for_tuples(30)]
pub trait OffchainWorker<BlockNumber> {
/// This function is being called after every block import (when fully synced).
///
/// Implement this and use any of the `Offchain` `sp_io` set of APIs
/// to perform off-chain computations, calls and submit transactions
/// with results to trigger any on-chain changes.
/// Any state alterations are lost and are not persisted.
fn offchain_worker(_n: BlockNumber) {}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn on_initialize_and_on_runtime_upgrade_weight_merge_works() {
struct Test;
impl OnInitialize<u8> for Test {
fn on_initialize(_n: u8) -> crate::weights::Weight {
10
}
}
impl OnRuntimeUpgrade for Test {
fn on_runtime_upgrade() -> crate::weights::Weight {
20
}
}
assert_eq!(<(Test, Test)>::on_initialize(0), 20);
assert_eq!(<(Test, Test)>::on_runtime_upgrade(), 40);
}
}
substrate/frame/support/src/weights.rs
+1 -41
View File
@@ -37,9 +37,8 @@
#[cfg(feature = "std")]
use serde::{Serialize, Deserialize};
use impl_trait_for_tuples::impl_for_tuples;
use codec::{Encode, Decode};
use sp_arithmetic::traits::{Bounded, Zero};
use sp_arithmetic::traits::Bounded;
use sp_runtime::{
RuntimeDebug,
traits::SignedExtension,
@@ -67,17 +66,6 @@ pub trait ClassifyDispatch<T> {
fn classify_dispatch(&self, target: T) -> DispatchClass;
}
/// Means of determining the weight of a block's life cycle hooks: `on_initialize`, `on_finalize`,
/// `on_runtime_upgrade`, and such.
pub trait WeighBlock<BlockNumber> {
/// Return the weight of the block's on_runtime_upgrade hook.
fn on_runtime_upgrade() -> Weight { Zero::zero() }
/// Return the weight of the block's on_initialize hook.
fn on_initialize(_: BlockNumber) -> Weight { Zero::zero() }
/// Return the weight of the block's on_finalize hook.
fn on_finalize(_: BlockNumber) -> Weight { Zero::zero() }
}
/// Indicates if dispatch function should pay fees or not.
/// If set to false, the block resource limits are applied, yet no fee is deducted.
pub trait PaysFee<T> {
@@ -86,34 +74,6 @@ pub trait PaysFee<T> {
}
}
/// Maybe I can do something to remove the duplicate code here.
#[impl_for_tuples(30)]
impl<BlockNumber: Copy> WeighBlock<BlockNumber> for SingleModule {
fn on_runtime_upgrade() -> Weight {
let mut accumulated_weight: Weight = Zero::zero();
for_tuples!(
#( accumulated_weight = accumulated_weight.saturating_add(SingleModule::on_runtime_upgrade()); )*
);
accumulated_weight
}
fn on_initialize(n: BlockNumber) -> Weight {
let mut accumulated_weight: Weight = Zero::zero();
for_tuples!(
#( accumulated_weight = accumulated_weight.saturating_add(SingleModule::on_initialize(n)); )*
);
accumulated_weight
}
fn on_finalize(n: BlockNumber) -> Weight {
let mut accumulated_weight: Weight = Zero::zero();
for_tuples!(
#( accumulated_weight = accumulated_weight.saturating_add(SingleModule::on_finalize(n)); )*
);
accumulated_weight
}
}
/// A generalized group of dispatch types. This is only distinguishing normal, user-triggered transactions
/// (`Normal`) and anything beyond which serves a higher purpose to the system (`Operational`).
#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
substrate/frame/treasury/src/benchmarking.rs
+1 -1
View File
@@ -20,7 +20,7 @@ use super::*;
use frame_system::RawOrigin;
use frame_benchmarking::{benchmarks, account};
use sp_runtime::traits::OnInitialize;
use frame_support::traits::OnInitialize;
use crate::Module as Treasury;
substrate/frame/treasury/src/lib.rs
+4 -2
View File
@@ -98,7 +98,7 @@ use frame_support::traits::{
use sp_runtime::{Permill, ModuleId, Percent, RuntimeDebug, traits::{
Zero, EnsureOrigin, StaticLookup, AccountIdConversion, Saturating, Hash, BadOrigin
}};
use frame_support::{weights::SimpleDispatchInfo, traits::Contains};
use frame_support::{weights::{Weight, WeighData, SimpleDispatchInfo}, traits::Contains};
use codec::{Encode, Decode};
use frame_system::{self as system, ensure_signed, ensure_root};
@@ -553,11 +553,13 @@ decl_module! {
Self::payout_tip(tip);
}
fn on_initialize(n: T::BlockNumber) {
fn on_initialize(n: T::BlockNumber) -> Weight {
// Check to see if we should spend some funds!
if (n % T::SpendPeriod::get()).is_zero() {
Self::spend_funds();
}
SimpleDispatchInfo::default().weigh_data(())
}
}
}
substrate/frame/treasury/src/tests.rs
+5 -3
View File
@@ -1,12 +1,14 @@
use super::*;
use frame_support::{assert_noop, assert_ok, impl_outer_origin, parameter_types, weights::Weight};
use frame_support::traits::Contains;
use frame_support::{
assert_noop, assert_ok, impl_outer_origin, parameter_types, weights::Weight,
traits::{Contains, OnInitialize}
};
use sp_core::H256;
use sp_runtime::{
Perbill,
testing::Header,
traits::{BlakeTwo256, OnInitialize, IdentityLookup, BadOrigin},
traits::{BlakeTwo256, IdentityLookup, BadOrigin},
};
impl_outer_origin! {
substrate/primitives/runtime/src/traits.rs
-45
View File
@@ -329,51 +329,6 @@ impl<T:
sp_std::ops::BitAnd<Self, Output = Self>
> SimpleBitOps for T {}
/// The block finalization trait. Implementing this lets you express what should happen
/// for your module when the block is ending.
#[impl_for_tuples(30)]
pub trait OnFinalize<BlockNumber> {
/// The block is being finalized. Implement to have something happen.
fn on_finalize(_n: BlockNumber) {}
}
/// The block initialization trait. Implementing this lets you express what should happen
/// for your module when the block is beginning (right before the first extrinsic is executed).
#[impl_for_tuples(30)]
pub trait OnInitialize<BlockNumber> {
/// The block is being initialized. Implement to have something happen.
fn on_initialize(_n: BlockNumber) {}
}
/// The runtime upgrade trait. Implementing this lets you express what should happen
/// when the runtime upgrades, and changes may need to occur to your module.
#[impl_for_tuples(30)]
pub trait OnRuntimeUpgrade {
/// Perform a module upgrade.
fn on_runtime_upgrade() {}
}
/// Off-chain computation trait.
///
/// Implementing this trait on a module allows you to perform long-running tasks
/// that make (by default) validators generate transactions that feed results
/// of those long-running computations back on chain.
///
/// NOTE: This function runs off-chain, so it can access the block state,
/// but cannot preform any alterations. More specifically alterations are
/// not forbidden, but they are not persisted in any way after the worker
/// has finished.
#[impl_for_tuples(30)]
pub trait OffchainWorker<BlockNumber> {
/// This function is being called after every block import (when fully synced).
///
/// Implement this and use any of the `Offchain` `sp_io` set of APIs
/// to perform off-chain computations, calls and submit transactions
/// with results to trigger any on-chain changes.
/// Any state alterations are lost and are not persisted.
fn offchain_worker(_n: BlockNumber) {}
}
/// Abstraction around hashing
// Stupid bug in the Rust compiler believes derived
// traits must be fulfilled by all type parameters.