// This file is part of Substrate. // Copyright (C) 2017-2021 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. //! # Executive Module //! //! The Executive module acts as the orchestration layer for the runtime. It dispatches incoming //! extrinsic calls to the respective modules in the runtime. //! //! ## Overview //! //! The executive module is not a typical pallet providing functionality around a specific feature. //! It is a cross-cutting framework component for the FRAME. It works in conjunction with the //! [FRAME System module](../frame_system/index.html) to perform these cross-cutting functions. //! //! The Executive module provides functions to: //! //! - Check transaction validity. //! - Initialize a block. //! - Apply extrinsics. //! - Execute a block. //! - Finalize a block. //! - Start an off-chain worker. //! //! ### Implementations //! //! The Executive module provides the following implementations: //! //! - `ExecuteBlock`: Trait that can be used to execute a block. //! - `Executive`: Type that can be used to make the FRAME available from the runtime. //! //! ## Usage //! //! The default Substrate node template declares the [`Executive`](./struct.Executive.html) type in //! its library. //! //! ### Example //! //! `Executive` type declaration from the node template. //! //! ``` //! # use sp_runtime::generic; //! # use frame_executive as executive; //! # pub struct UncheckedExtrinsic {}; //! # pub struct Header {}; //! # type Context = frame_system::ChainContext; //! # pub type Block = generic::Block; //! # pub type Balances = u64; //! # pub type AllPallets = u64; //! # pub enum Runtime {}; //! # use sp_runtime::transaction_validity::{ //! # TransactionValidity, UnknownTransaction, TransactionSource, //! # }; //! # use sp_runtime::traits::ValidateUnsigned; //! # impl ValidateUnsigned for Runtime { //! # type Call = (); //! # //! # fn validate_unsigned(_source: TransactionSource, _call: &Self::Call) -> TransactionValidity { //! # UnknownTransaction::NoUnsignedValidator.into() //! # } //! # } //! /// Executive: handles dispatch to the various modules. //! pub type Executive = executive::Executive; //! ``` //! //! ### Custom `OnRuntimeUpgrade` logic //! //! You can add custom logic that should be called in your runtime on a runtime upgrade. This is //! done by setting an optional generic parameter. The custom logic will be called before //! the on runtime upgrade logic of all modules is called. //! //! ``` //! # use sp_runtime::generic; //! # use frame_executive as executive; //! # pub struct UncheckedExtrinsic {}; //! # pub struct Header {}; //! # type Context = frame_system::ChainContext; //! # pub type Block = generic::Block; //! # pub type Balances = u64; //! # pub type AllPallets = u64; //! # pub enum Runtime {}; //! # use sp_runtime::transaction_validity::{ //! # TransactionValidity, UnknownTransaction, TransactionSource, //! # }; //! # use sp_runtime::traits::ValidateUnsigned; //! # impl ValidateUnsigned for Runtime { //! # type Call = (); //! # //! # fn validate_unsigned(_source: TransactionSource, _call: &Self::Call) -> TransactionValidity { //! # UnknownTransaction::NoUnsignedValidator.into() //! # } //! # } //! struct CustomOnRuntimeUpgrade; //! impl frame_support::traits::OnRuntimeUpgrade for CustomOnRuntimeUpgrade { //! fn on_runtime_upgrade() -> frame_support::weights::Weight { //! // Do whatever you want. //! 0 //! } //! } //! //! pub type Executive = executive::Executive; //! ``` #![cfg_attr(not(feature = "std"), no_std)] use sp_std::{prelude::*, marker::PhantomData}; use frame_support::{ weights::{GetDispatchInfo, DispatchInfo, DispatchClass}, traits::{OnInitialize, OnIdle, OnFinalize, OnRuntimeUpgrade, OffchainWorker, ExecuteBlock}, dispatch::PostDispatchInfo, }; use sp_runtime::{ generic::Digest, ApplyExtrinsicResult, traits::{ self, Header, Zero, One, Checkable, Applyable, CheckEqual, ValidateUnsigned, NumberFor, Dispatchable, Saturating, }, transaction_validity::{TransactionValidity, TransactionSource}, }; use codec::{Codec, Encode}; use frame_system::DigestOf; pub type CheckedOf = >::Checked; pub type CallOf = as Applyable>::Call; pub type OriginOf = as Dispatchable>::Origin; /// Main entry point for certain runtime actions as e.g. `execute_block`. /// /// Generic parameters: /// - `System`: Something that implements `frame_system::Config` /// - `Block`: The block type of the runtime /// - `Context`: The context that is used when checking an extrinsic. /// - `UnsignedValidator`: The unsigned transaction validator of the runtime. /// - `AllPallets`: Tuple that contains all modules. Will be used to call e.g. `on_initialize`. /// - `OnRuntimeUpgrade`: Custom logic that should be called after a runtime upgrade. Modules are /// already called by `AllPallets`. It will be called before all modules will /// be called. pub struct Executive( PhantomData<(System, Block, Context, UnsignedValidator, AllPallets, OnRuntimeUpgrade)> ); impl< System: frame_system::Config, Block: traits::Block, Context: Default, UnsignedValidator, AllPallets: OnRuntimeUpgrade + OnInitialize + OnIdle + OnFinalize + OffchainWorker, COnRuntimeUpgrade: OnRuntimeUpgrade, > ExecuteBlock for Executive where Block::Extrinsic: Checkable + Codec, CheckedOf: Applyable + GetDispatchInfo, CallOf: Dispatchable, OriginOf: From>, UnsignedValidator: ValidateUnsigned>, { fn execute_block(block: Block) { Executive::::execute_block(block); } } impl< System: frame_system::Config, Block: traits::Block
, Context: Default, UnsignedValidator, AllPallets: OnRuntimeUpgrade + OnInitialize + OnIdle + OnFinalize + OffchainWorker, COnRuntimeUpgrade: OnRuntimeUpgrade, > Executive where Block::Extrinsic: Checkable + Codec, CheckedOf: Applyable + GetDispatchInfo, CallOf: Dispatchable, OriginOf: From>, UnsignedValidator: ValidateUnsigned>, { /// Execute all `OnRuntimeUpgrade` of this runtime, and return the aggregate weight. pub fn execute_on_runtime_upgrade() -> frame_support::weights::Weight { let mut weight = 0; weight = weight.saturating_add( as OnRuntimeUpgrade>::on_runtime_upgrade(), ); weight = weight.saturating_add(COnRuntimeUpgrade::on_runtime_upgrade()); weight = weight.saturating_add(::on_runtime_upgrade()); weight } /// Execute all `OnRuntimeUpgrade` of this runtime, including the pre and post migration checks. /// /// This should only be used for testing. #[cfg(feature = "try-runtime")] pub fn try_runtime_upgrade() -> Result { < (frame_system::Pallet::, COnRuntimeUpgrade, AllPallets) as OnRuntimeUpgrade >::pre_upgrade()?; let weight = Self::execute_on_runtime_upgrade(); < (frame_system::Pallet::, COnRuntimeUpgrade, AllPallets) as OnRuntimeUpgrade >::post_upgrade()?; Ok(weight) } /// Start the execution of a particular block. pub fn initialize_block(header: &System::Header) { sp_io::init_tracing(); sp_tracing::enter_span!(sp_tracing::Level::TRACE, "init_block"); let digests = Self::extract_pre_digest(&header); Self::initialize_block_impl( header.number(), header.parent_hash(), &digests ); } fn extract_pre_digest(header: &System::Header) -> DigestOf { let mut digest = >::default(); header.digest().logs() .iter() .for_each(|d| if d.as_pre_runtime().is_some() { digest.push(d.clone()) }); digest } fn initialize_block_impl( block_number: &System::BlockNumber, parent_hash: &System::Hash, digest: &Digest, ) { let mut weight = 0; if Self::runtime_upgraded() { weight = weight.saturating_add(Self::execute_on_runtime_upgrade()); } >::initialize( block_number, parent_hash, digest, frame_system::InitKind::Full, ); weight = weight.saturating_add( as OnInitialize>::on_initialize(*block_number) ); weight = weight.saturating_add( >::on_initialize(*block_number) ); weight = weight.saturating_add( >::get().base_block ); >::register_extra_weight_unchecked(weight, DispatchClass::Mandatory); frame_system::Pallet::::note_finished_initialize(); } /// Returns if the runtime was upgraded since the last time this function was called. fn runtime_upgraded() -> bool { let last = frame_system::LastRuntimeUpgrade::::get(); let current = >::get(); if last.map(|v| v.was_upgraded(¤t)).unwrap_or(true) { frame_system::LastRuntimeUpgrade::::put( frame_system::LastRuntimeUpgradeInfo::from(current), ); true } else { false } } fn initial_checks(block: &Block) { sp_tracing::enter_span!(sp_tracing::Level::TRACE, "initial_checks"); let header = block.header(); // Check that `parent_hash` is correct. let n = header.number().clone(); assert!( n > System::BlockNumber::zero() && >::block_hash(n - System::BlockNumber::one()) == *header.parent_hash(), "Parent hash should be valid.", ); } /// Actually execute all transitions for `block`. pub fn execute_block(block: Block) { sp_io::init_tracing(); sp_tracing::within_span! { sp_tracing::info_span!("execute_block", ?block); Self::initialize_block(block.header()); // any initial checks Self::initial_checks(&block); let signature_batching = sp_runtime::SignatureBatching::start(); // execute extrinsics let (header, extrinsics) = block.deconstruct(); Self::execute_extrinsics_with_book_keeping(extrinsics, *header.number()); if !signature_batching.verify() { panic!("Signature verification failed."); } // any final checks Self::final_checks(&header); } } /// Execute given extrinsics and take care of post-extrinsics book-keeping. fn execute_extrinsics_with_book_keeping( extrinsics: Vec, block_number: NumberFor, ) { extrinsics.into_iter().for_each(|e| if let Err(e) = Self::apply_extrinsic(e) { let err: &'static str = e.into(); panic!("{}", err) }); // post-extrinsics book-keeping >::note_finished_extrinsics(); Self::idle_and_finalize_hook(block_number); } /// Finalize the block - it is up the caller to ensure that all header fields are valid /// except state-root. pub fn finalize_block() -> System::Header { sp_io::init_tracing(); sp_tracing::enter_span!( sp_tracing::Level::TRACE, "finalize_block" ); >::note_finished_extrinsics(); let block_number = >::block_number(); Self::idle_and_finalize_hook(block_number); >::finalize() } fn idle_and_finalize_hook(block_number: NumberFor) { let weight = >::block_weight(); let max_weight = >::get().max_block; let mut remaining_weight = max_weight.saturating_sub(weight.total()); if remaining_weight > 0 { let mut used_weight = as OnIdle>::on_idle( block_number, remaining_weight ); remaining_weight = remaining_weight.saturating_sub(used_weight); used_weight = >::on_idle( block_number, remaining_weight ) .saturating_add(used_weight); >::register_extra_weight_unchecked(used_weight, DispatchClass::Mandatory); } as OnFinalize>::on_finalize(block_number); >::on_finalize(block_number); } /// Apply extrinsic outside of the block execution function. /// /// This doesn't attempt to validate anything regarding the block, but it builds a list of uxt /// hashes. pub fn apply_extrinsic(uxt: Block::Extrinsic) -> ApplyExtrinsicResult { sp_io::init_tracing(); let encoded = uxt.encode(); let encoded_len = encoded.len(); Self::apply_extrinsic_with_len(uxt, encoded_len, encoded) } /// Actually apply an extrinsic given its `encoded_len`; this doesn't note its hash. fn apply_extrinsic_with_len( uxt: Block::Extrinsic, encoded_len: usize, to_note: Vec, ) -> ApplyExtrinsicResult { sp_tracing::enter_span!( sp_tracing::info_span!("apply_extrinsic", ext=?sp_core::hexdisplay::HexDisplay::from(&uxt.encode())) ); // Verify that the signature is good. let xt = uxt.check(&Default::default())?; // We don't need to make sure to `note_extrinsic` only after we know it's going to be // executed to prevent it from leaking in storage since at this point, it will either // execute or panic (and revert storage changes). >::note_extrinsic(to_note); // AUDIT: Under no circumstances may this function panic from here onwards. // Decode parameters and dispatch let dispatch_info = xt.get_dispatch_info(); let r = Applyable::apply::(xt, &dispatch_info, encoded_len)?; >::note_applied_extrinsic(&r, dispatch_info); Ok(r.map(|_| ()).map_err(|e| e.error)) } fn final_checks(header: &System::Header) { sp_tracing::enter_span!(sp_tracing::Level::TRACE, "final_checks"); // remove temporaries let new_header = >::finalize(); // check digest assert_eq!( header.digest().logs().len(), new_header.digest().logs().len(), "Number of digest items must match that calculated." ); let items_zip = header.digest().logs().iter().zip(new_header.digest().logs().iter()); for (header_item, computed_item) in items_zip { header_item.check_equal(&computed_item); assert!(header_item == computed_item, "Digest item must match that calculated."); } // check storage root. let storage_root = new_header.state_root(); header.state_root().check_equal(&storage_root); assert!(header.state_root() == storage_root, "Storage root must match that calculated."); assert!( header.extrinsics_root() == new_header.extrinsics_root(), "Transaction trie root must be valid.", ); } /// Check a given signed transaction for validity. This doesn't execute any /// side-effects; it merely checks whether the transaction would panic if it were included or not. /// /// Changes made to storage should be discarded. pub fn validate_transaction( source: TransactionSource, uxt: Block::Extrinsic, ) -> TransactionValidity { sp_io::init_tracing(); use sp_tracing::{enter_span, within_span}; enter_span!{ sp_tracing::Level::TRACE, "validate_transaction" }; let encoded_len = within_span!{ sp_tracing::Level::TRACE, "using_encoded"; uxt.using_encoded(|d| d.len()) }; let xt = within_span!{ sp_tracing::Level::TRACE, "check"; uxt.check(&Default::default()) }?; let dispatch_info = within_span!{ sp_tracing::Level::TRACE, "dispatch_info"; xt.get_dispatch_info() }; within_span! { sp_tracing::Level::TRACE, "validate"; xt.validate::(source, &dispatch_info, encoded_len) } } /// Start an offchain worker and generate extrinsics. pub fn offchain_worker(header: &System::Header) { sp_io::init_tracing(); // We need to keep events available for offchain workers, // hence we initialize the block manually. // OffchainWorker RuntimeApi should skip initialization. let digests = header.digest().clone(); >::initialize( header.number(), header.parent_hash(), &digests, frame_system::InitKind::Inspection, ); // Frame system only inserts the parent hash into the block hashes as normally we don't know // the hash for the header before. However, here we are aware of the hash and we can add it // as well. frame_system::BlockHash::::insert(header.number(), header.hash()); >::offchain_worker(*header.number()) } } #[cfg(test)] mod tests { use super::*; use sp_core::H256; use sp_runtime::{ generic::{Era, DigestItem}, DispatchError, testing::{Digest, Header, Block}, traits::{Header as HeaderT, BlakeTwo256, IdentityLookup, Block as BlockT}, transaction_validity::{ InvalidTransaction, ValidTransaction, TransactionValidityError, UnknownTransaction }, }; use frame_support::{ parameter_types, weights::{Weight, RuntimeDbWeight, IdentityFee, WeightToFeePolynomial}, traits::{Currency, LockIdentifier, LockableCurrency, WithdrawReasons}, }; use frame_system::{ Call as SystemCall, ChainContext, LastRuntimeUpgradeInfo, }; use pallet_transaction_payment::CurrencyAdapter; use pallet_balances::Call as BalancesCall; use hex_literal::hex; const TEST_KEY: &[u8] = &*b":test:key:"; mod custom { use frame_support::weights::{Weight, DispatchClass}; use sp_runtime::transaction_validity::{ UnknownTransaction, TransactionSource, TransactionValidity }; pub trait Config: frame_system::Config {} frame_support::decl_module! { pub struct Module for enum Call where origin: T::Origin { #[weight = 100] fn some_function(origin) { // NOTE: does not make any different. let _ = frame_system::ensure_signed(origin); } #[weight = (200, DispatchClass::Operational)] fn some_root_operation(origin) { let _ = frame_system::ensure_root(origin); } #[weight = 0] fn some_unsigned_message(origin) { let _ = frame_system::ensure_none(origin); } #[weight = 0] fn allowed_unsigned(origin) { let _ = frame_system::ensure_root(origin)?; } #[weight = 0] fn unallowed_unsigned(origin) { let _ = frame_system::ensure_root(origin)?; } // module hooks. // one with block number arg and one without fn on_initialize(n: T::BlockNumber) -> Weight { println!("on_initialize({})", n); 175 } fn on_idle(n: T::BlockNumber, remaining_weight: Weight) -> Weight { println!("on_idle{}, {})", n, remaining_weight); 175 } fn on_finalize() { println!("on_finalize(?)"); } fn on_runtime_upgrade() -> Weight { sp_io::storage::set(super::TEST_KEY, "module".as_bytes()); 200 } fn offchain_worker(n: T::BlockNumber) { assert_eq!(T::BlockNumber::from(1u32), n); } #[weight = 0] fn calculate_storage_root(origin) { let root = sp_io::storage::root(); sp_io::storage::set("storage_root".as_bytes(), &root); } } } impl sp_runtime::traits::ValidateUnsigned for Module { type Call = Call; fn validate_unsigned( _source: TransactionSource, call: &Self::Call, ) -> TransactionValidity { match call { Call::allowed_unsigned(..) => Ok(Default::default()), _ => UnknownTransaction::NoUnsignedValidator.into(), } } } } frame_support::construct_runtime!( pub enum Runtime where Block = TestBlock, NodeBlock = TestBlock, UncheckedExtrinsic = TestUncheckedExtrinsic { System: frame_system::{Pallet, Call, Config, Storage, Event}, Balances: pallet_balances::{Pallet, Call, Storage, Config, Event}, Custom: custom::{Pallet, Call, ValidateUnsigned}, } ); parameter_types! { pub const BlockHashCount: u64 = 250; pub BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights::builder() .base_block(10) .for_class(DispatchClass::all(), |weights| weights.base_extrinsic = 5) .for_class(DispatchClass::non_mandatory(), |weights| weights.max_total = 1024.into()) .build_or_panic(); pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight { read: 10, write: 100, }; } impl frame_system::Config for Runtime { type BaseCallFilter = (); type BlockWeights = BlockWeights; type BlockLength = (); type DbWeight = (); type Origin = Origin; type Index = u64; type Call = Call; type BlockNumber = u64; type Hash = sp_core::H256; type Hashing = BlakeTwo256; type AccountId = u64; type Lookup = IdentityLookup; type Header = Header; type Event = Event; type BlockHashCount = BlockHashCount; type Version = RuntimeVersion; type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; type OnNewAccount = (); type OnKilledAccount = (); type SystemWeightInfo = (); type SS58Prefix = (); } type Balance = u64; parameter_types! { pub const ExistentialDeposit: Balance = 1; } impl pallet_balances::Config for Runtime { type Balance = Balance; type Event = Event; type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; type MaxLocks = (); type WeightInfo = (); } parameter_types! { pub const TransactionByteFee: Balance = 0; } impl pallet_transaction_payment::Config for Runtime { type OnChargeTransaction = CurrencyAdapter; type TransactionByteFee = TransactionByteFee; type WeightToFee = IdentityFee; type FeeMultiplierUpdate = (); } impl custom::Config for Runtime {} pub struct RuntimeVersion; impl frame_support::traits::Get for RuntimeVersion { fn get() -> sp_version::RuntimeVersion { RUNTIME_VERSION.with(|v| v.borrow().clone()) } } thread_local! { pub static RUNTIME_VERSION: std::cell::RefCell = Default::default(); } type SignedExtra = ( frame_system::CheckEra, frame_system::CheckNonce, frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, ); type TestXt = sp_runtime::testing::TestXt; type TestBlock = Block; type TestUncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic< ::AccountId, ::Call, (), SignedExtra, >; // Will contain `true` when the custom runtime logic was called. const CUSTOM_ON_RUNTIME_KEY: &[u8] = &*b":custom:on_runtime"; struct CustomOnRuntimeUpgrade; impl OnRuntimeUpgrade for CustomOnRuntimeUpgrade { fn on_runtime_upgrade() -> Weight { sp_io::storage::set(TEST_KEY, "custom_upgrade".as_bytes()); sp_io::storage::set(CUSTOM_ON_RUNTIME_KEY, &true.encode()); 100 } } type Executive = super::Executive< Runtime, Block, ChainContext, Runtime, AllPallets, CustomOnRuntimeUpgrade >; fn extra(nonce: u64, fee: Balance) -> SignedExtra { ( frame_system::CheckEra::from(Era::Immortal), frame_system::CheckNonce::from(nonce), frame_system::CheckWeight::new(), pallet_transaction_payment::ChargeTransactionPayment::from(fee) ) } fn sign_extra(who: u64, nonce: u64, fee: Balance) -> Option<(u64, SignedExtra)> { Some((who, extra(nonce, fee))) } #[test] fn balance_transfer_dispatch_works() { let mut t = frame_system::GenesisConfig::default().build_storage::().unwrap(); pallet_balances::GenesisConfig:: { balances: vec![(1, 211)], }.assimilate_storage(&mut t).unwrap(); let xt = TestXt::new(Call::Balances(BalancesCall::transfer(2, 69)), sign_extra(1, 0, 0)); let weight = xt.get_dispatch_info().weight + ::BlockWeights::get().get(DispatchClass::Normal).base_extrinsic; let fee: Balance = ::WeightToFee::calc(&weight); let mut t = sp_io::TestExternalities::new(t); t.execute_with(|| { Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); let r = Executive::apply_extrinsic(xt); assert!(r.is_ok()); assert_eq!(>::total_balance(&1), 142 - fee); assert_eq!(>::total_balance(&2), 69); }); } fn new_test_ext(balance_factor: Balance) -> sp_io::TestExternalities { let mut t = frame_system::GenesisConfig::default().build_storage::().unwrap(); pallet_balances::GenesisConfig:: { balances: vec![(1, 111 * balance_factor)], }.assimilate_storage(&mut t).unwrap(); t.into() } #[test] fn block_import_works() { new_test_ext(1).execute_with(|| { Executive::execute_block(Block { header: Header { parent_hash: [69u8; 32].into(), number: 1, state_root: hex!("6e70de4fa07bac443dc7f8a812c8a0c941aacfa892bb373c5899f7d511d4c25b").into(), extrinsics_root: hex!("03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314").into(), digest: Digest { logs: vec![], }, }, extrinsics: vec![], }); }); } #[test] #[should_panic] fn block_import_of_bad_state_root_fails() { new_test_ext(1).execute_with(|| { Executive::execute_block(Block { header: Header { parent_hash: [69u8; 32].into(), number: 1, state_root: [0u8; 32].into(), extrinsics_root: hex!("03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314").into(), digest: Digest { logs: vec![], }, }, extrinsics: vec![], }); }); } #[test] #[should_panic] fn block_import_of_bad_extrinsic_root_fails() { new_test_ext(1).execute_with(|| { Executive::execute_block(Block { header: Header { parent_hash: [69u8; 32].into(), number: 1, state_root: hex!("49cd58a254ccf6abc4a023d9a22dcfc421e385527a250faec69f8ad0d8ed3e48").into(), extrinsics_root: [0u8; 32].into(), digest: Digest { logs: vec![], }, }, extrinsics: vec![], }); }); } #[test] fn bad_extrinsic_not_inserted() { let mut t = new_test_ext(1); // bad nonce check! let xt = TestXt::new(Call::Balances(BalancesCall::transfer(33, 69)), sign_extra(1, 30, 0)); t.execute_with(|| { Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); assert!(Executive::apply_extrinsic(xt).is_err()); assert_eq!(>::extrinsic_index(), Some(0)); }); } #[test] fn block_weight_limit_enforced() { let mut t = new_test_ext(10000); // given: TestXt uses the encoded len as fixed Len: let xt = TestXt::new(Call::Balances(BalancesCall::transfer(33, 0)), sign_extra(1, 0, 0)); let encoded = xt.encode(); let encoded_len = encoded.len() as Weight; // on_initialize weight + base block execution weight let block_weights = ::BlockWeights::get(); let base_block_weight = 175 + block_weights.base_block; let limit = block_weights.get(DispatchClass::Normal).max_total.unwrap() - base_block_weight; let num_to_exhaust_block = limit / (encoded_len + 5); t.execute_with(|| { Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); // Base block execution weight + `on_initialize` weight from the custom module. assert_eq!(>::block_weight().total(), base_block_weight); for nonce in 0..=num_to_exhaust_block { let xt = TestXt::new( Call::Balances(BalancesCall::transfer(33, 0)), sign_extra(1, nonce.into(), 0), ); let res = Executive::apply_extrinsic(xt); if nonce != num_to_exhaust_block { assert!(res.is_ok()); assert_eq!( >::block_weight().total(), //--------------------- on_initialize + block_execution + extrinsic_base weight (encoded_len + 5) * (nonce + 1) + base_block_weight, ); assert_eq!(>::extrinsic_index(), Some(nonce as u32 + 1)); } else { assert_eq!(res, Err(InvalidTransaction::ExhaustsResources.into())); } } }); } #[test] fn block_weight_and_size_is_stored_per_tx() { let xt = TestXt::new(Call::Balances(BalancesCall::transfer(33, 0)), sign_extra(1, 0, 0)); let x1 = TestXt::new(Call::Balances(BalancesCall::transfer(33, 0)), sign_extra(1, 1, 0)); let x2 = TestXt::new(Call::Balances(BalancesCall::transfer(33, 0)), sign_extra(1, 2, 0)); let len = xt.clone().encode().len() as u32; let mut t = new_test_ext(1); t.execute_with(|| { // Block execution weight + on_initialize weight from custom module let base_block_weight = 175 + ::BlockWeights::get().base_block; Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); assert_eq!(>::block_weight().total(), base_block_weight); assert_eq!(>::all_extrinsics_len(), 0); assert!(Executive::apply_extrinsic(xt.clone()).unwrap().is_ok()); assert!(Executive::apply_extrinsic(x1.clone()).unwrap().is_ok()); assert!(Executive::apply_extrinsic(x2.clone()).unwrap().is_ok()); // default weight for `TestXt` == encoded length. let extrinsic_weight = len as Weight + ::BlockWeights ::get().get(DispatchClass::Normal).base_extrinsic; assert_eq!( >::block_weight().total(), base_block_weight + 3 * extrinsic_weight, ); assert_eq!(>::all_extrinsics_len(), 3 * len); let _ = >::finalize(); // All extrinsics length cleaned on `System::finalize` assert_eq!(>::all_extrinsics_len(), 0); // New Block Executive::initialize_block(&Header::new( 2, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); // Block weight cleaned up on `System::initialize` assert_eq!(>::block_weight().total(), base_block_weight); }); } #[test] fn validate_unsigned() { let valid = TestXt::new(Call::Custom(custom::Call::allowed_unsigned()), None); let invalid = TestXt::new(Call::Custom(custom::Call::unallowed_unsigned()), None); let mut t = new_test_ext(1); let mut default_with_prio_3 = ValidTransaction::default(); default_with_prio_3.priority = 3; t.execute_with(|| { assert_eq!( Executive::validate_transaction(TransactionSource::InBlock, valid.clone()), Ok(default_with_prio_3), ); assert_eq!( Executive::validate_transaction(TransactionSource::InBlock, invalid.clone()), Err(TransactionValidityError::Unknown(UnknownTransaction::NoUnsignedValidator)), ); assert_eq!(Executive::apply_extrinsic(valid), Ok(Err(DispatchError::BadOrigin))); assert_eq!( Executive::apply_extrinsic(invalid), Err(TransactionValidityError::Unknown(UnknownTransaction::NoUnsignedValidator)) ); }); } #[test] fn can_pay_for_tx_fee_on_full_lock() { let id: LockIdentifier = *b"0 "; let execute_with_lock = |lock: WithdrawReasons| { let mut t = new_test_ext(1); t.execute_with(|| { as LockableCurrency>::set_lock( id, &1, 110, lock, ); let xt = TestXt::new( Call::System(SystemCall::remark(vec![1u8])), sign_extra(1, 0, 0), ); let weight = xt.get_dispatch_info().weight + ::BlockWeights ::get() .get(DispatchClass::Normal) .base_extrinsic; let fee: Balance = ::WeightToFee::calc(&weight); Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); if lock == WithdrawReasons::except(WithdrawReasons::TRANSACTION_PAYMENT) { assert!(Executive::apply_extrinsic(xt).unwrap().is_ok()); // tx fee has been deducted. assert_eq!(>::total_balance(&1), 111 - fee); } else { assert_eq!( Executive::apply_extrinsic(xt), Err(InvalidTransaction::Payment.into()), ); assert_eq!(>::total_balance(&1), 111); } }); }; execute_with_lock(WithdrawReasons::all()); execute_with_lock(WithdrawReasons::except(WithdrawReasons::TRANSACTION_PAYMENT)); } #[test] fn block_hooks_weight_is_stored() { new_test_ext(1).execute_with(|| { Executive::initialize_block(&Header::new_from_number(1)); Executive::finalize_block(); // NOTE: might need updates over time if new weights are introduced. // For now it only accounts for the base block execution weight and // the `on_initialize` weight defined in the custom test module. assert_eq!(>::block_weight().total(), 175 + 175 + 10); }) } #[test] fn runtime_upgraded_should_work() { new_test_ext(1).execute_with(|| { RUNTIME_VERSION.with(|v| *v.borrow_mut() = Default::default()); // It should be added at genesis assert!(frame_system::LastRuntimeUpgrade::::exists()); assert!(!Executive::runtime_upgraded()); RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }); assert!(Executive::runtime_upgraded()); assert_eq!( Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "".into() }), frame_system::LastRuntimeUpgrade::::get(), ); RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion { spec_version: 1, spec_name: "test".into(), ..Default::default() }); assert!(Executive::runtime_upgraded()); assert_eq!( Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "test".into() }), frame_system::LastRuntimeUpgrade::::get(), ); RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion { spec_version: 1, spec_name: "test".into(), impl_version: 2, ..Default::default() }); assert!(!Executive::runtime_upgraded()); frame_system::LastRuntimeUpgrade::::take(); assert!(Executive::runtime_upgraded()); assert_eq!( Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "test".into() }), frame_system::LastRuntimeUpgrade::::get(), ); }) } #[test] fn last_runtime_upgrade_was_upgraded_works() { let test_data = vec![ (0, "", 1, "", true), (1, "", 1, "", false), (1, "", 1, "test", true), (1, "", 0, "", false), (1, "", 0, "test", true), ]; for (spec_version, spec_name, c_spec_version, c_spec_name, result) in test_data { let current = sp_version::RuntimeVersion { spec_version: c_spec_version, spec_name: c_spec_name.into(), ..Default::default() }; let last = LastRuntimeUpgradeInfo { spec_version: spec_version.into(), spec_name: spec_name.into(), }; assert_eq!(result, last.was_upgraded(¤t)); } } #[test] fn custom_runtime_upgrade_is_called_before_modules() { new_test_ext(1).execute_with(|| { // Make sure `on_runtime_upgrade` is called. RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }); Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); assert_eq!(&sp_io::storage::get(TEST_KEY).unwrap()[..], *b"module"); assert_eq!(sp_io::storage::get(CUSTOM_ON_RUNTIME_KEY).unwrap(), true.encode()); }); } #[test] fn all_weights_are_recorded_correctly() { new_test_ext(1).execute_with(|| { // Make sure `on_runtime_upgrade` is called for maximum complexity RUNTIME_VERSION.with(|v| *v.borrow_mut() = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }); let block_number = 1; Executive::initialize_block(&Header::new( block_number, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); // All weights that show up in the `initialize_block_impl` let frame_system_upgrade_weight = frame_system::Pallet::::on_runtime_upgrade(); let custom_runtime_upgrade_weight = CustomOnRuntimeUpgrade::on_runtime_upgrade(); let runtime_upgrade_weight = ::on_runtime_upgrade(); let frame_system_on_initialize_weight = frame_system::Pallet::::on_initialize(block_number); let on_initialize_weight = >::on_initialize(block_number); let base_block_weight = ::BlockWeights::get().base_block; // Weights are recorded correctly assert_eq!( frame_system::Pallet::::block_weight().total(), frame_system_upgrade_weight + custom_runtime_upgrade_weight + runtime_upgrade_weight + frame_system_on_initialize_weight + on_initialize_weight + base_block_weight, ); }); } #[test] fn offchain_worker_works_as_expected() { new_test_ext(1).execute_with(|| { let parent_hash = sp_core::H256::from([69u8; 32]); let mut digest = Digest::default(); digest.push(DigestItem::Seal([1, 2, 3, 4], vec![5, 6, 7, 8])); let header = Header::new( 1, H256::default(), H256::default(), parent_hash, digest.clone(), ); Executive::offchain_worker(&header); assert_eq!(digest, System::digest()); assert_eq!(parent_hash, System::block_hash(0)); assert_eq!(header.hash(), System::block_hash(1)); }); } #[test] fn calculating_storage_root_twice_works() { let call = Call::Custom(custom::Call::calculate_storage_root()); let xt = TestXt::new(call, sign_extra(1, 0, 0)); let header = new_test_ext(1).execute_with(|| { // Let's build some fake block. Executive::initialize_block(&Header::new( 1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default(), )); Executive::apply_extrinsic(xt.clone()).unwrap().unwrap(); Executive::finalize_block() }); new_test_ext(1).execute_with(|| { Executive::execute_block(Block::new(header, vec![xt])); }); } }