// This file is part of Substrate.

// Copyright (C) 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.

#![cfg_attr(not(feature = "std"), no_std)]

//! # 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.

//!

//! The flow of their application in a block is explained in the [block flowchart](block_flowchart).

//!

//! ### 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<Runtime>;

//! # pub type Block = generic::Block<Header, UncheckedExtrinsic>;

//! # pub type Balances = u64;

//! # pub type AllPalletsWithSystem = 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<Runtime, Block, Context, Runtime, AllPalletsWithSystem>;

//! ```

//!

//! ### 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<Runtime>;

//! # pub type Block = generic::Block<Header, UncheckedExtrinsic>;

//! # pub type Balances = u64;

//! # pub type AllPalletsWithSystem = 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.

//!         frame_support::weights::Weight::zero()

//!     }

//! }

//!

//! pub type Executive = executive::Executive<Runtime, Block, Context, Runtime, AllPalletsWithSystem, CustomOnRuntimeUpgrade>;

//! ```

#[cfg(doc)]

#[cfg_attr(doc, aquamarine::aquamarine)]

/// # Block Execution

///

/// These are the steps of block execution as done by [`Executive::execute_block`]. A block is

/// invalid if any of them fail.

///

/// ```mermaid

/// flowchart TD

///     Executive::execute_block --> on_runtime_upgrade

///     on_runtime_upgrade --> System::initialize

///     Executive::initialize_block --> System::initialize

///     System::initialize --> on_initialize

///     on_initialize --> PreInherents[System::PreInherents]

///     PreInherents --> Inherents[Apply Inherents]

///     Inherents --> PostInherents[System::PostInherents]

///     PostInherents --> Check{MBM ongoing?}

///     Check -->|No| poll

///     Check -->|Yes| post_transactions_2[System::PostTransaction]

///     post_transactions_2 --> Step[MBMs::step]

///     Step --> on_finalize

///     poll --> transactions[Apply Transactions]

///     transactions --> post_transactions_1[System::PostTransaction]

///     post_transactions_1 --> CheckIdle{Weight remaining?}

///     CheckIdle -->|Yes| on_idle

///     CheckIdle -->|No| on_finalize

///     on_idle --> on_finalize

/// ```

pub mod block_flowchart {}

#[cfg(test)]

mod tests;

extern crate alloc;

use codec::{Codec, Encode};

use core::marker::PhantomData;

use frame_support::{

	defensive_assert,

	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, PostDispatchInfo},

	migrations::MultiStepMigrator,

	pallet_prelude::InvalidTransaction,

	traits::{

		BeforeAllRuntimeMigrations, EnsureInherentsAreFirst, ExecuteBlock, OffchainWorker,

		OnFinalize, OnIdle, OnInitialize, OnPoll, OnRuntimeUpgrade, PostInherents,

		PostTransactions, PreInherents,

	},

	weights::{Weight, WeightMeter},

};

use frame_system::pallet_prelude::BlockNumberFor;

use sp_runtime::{

	generic::Digest,

	traits::{

		self, Applyable, CheckEqual, Checkable, Dispatchable, Header, NumberFor, One,

		ValidateUnsigned, Zero,

	},

	transaction_validity::{TransactionSource, TransactionValidity},

	ApplyExtrinsicResult, ExtrinsicInclusionMode,

};

#[cfg(feature = "try-runtime")]

use ::{

	frame_support::{

		traits::{TryDecodeEntireStorage, TryDecodeEntireStorageError, TryState},

		StorageNoopGuard,

	},

	frame_try_runtime::{TryStateSelect, UpgradeCheckSelect},

	log,

	sp_runtime::TryRuntimeError,

};

#[allow(dead_code)]

const LOG_TARGET: &str = "runtime::executive";

pub type CheckedOf<E, C> = <E as Checkable<C>>::Checked;

pub type CallOf<E, C> = <CheckedOf<E, C> as Applyable>::Call;

pub type OriginOf<E, C> = <CallOf<E, C> as Dispatchable>::RuntimeOrigin;

/// 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.

/// - `AllPalletsWithSystem`: Tuple that contains all pallets including frame system pallet. Will be

///   used to call hooks e.g. `on_initialize`.

/// - `OnRuntimeUpgrade`: Custom logic that should be called after a runtime upgrade. Modules are

///   already called by `AllPalletsWithSystem`. It will be called before all modules will be called.

pub struct Executive<

	System,

	Block,

	Context,

	UnsignedValidator,

	AllPalletsWithSystem,

	OnRuntimeUpgrade = (),

>(

	PhantomData<(

		System,

		Block,

		Context,

		UnsignedValidator,

		AllPalletsWithSystem,

		OnRuntimeUpgrade,

	)>,

);

impl<

		System: frame_system::Config + EnsureInherentsAreFirst<Block>,

		Block: traits::Block<

			Header = frame_system::pallet_prelude::HeaderFor<System>,

			Hash = System::Hash,

		>,

		Context: Default,

		UnsignedValidator,

		AllPalletsWithSystem: OnRuntimeUpgrade

			+ BeforeAllRuntimeMigrations

			+ OnInitialize<BlockNumberFor<System>>

			+ OnIdle<BlockNumberFor<System>>

			+ OnFinalize<BlockNumberFor<System>>

			+ OffchainWorker<BlockNumberFor<System>>

			+ OnPoll<BlockNumberFor<System>>,

		COnRuntimeUpgrade: OnRuntimeUpgrade,

	> ExecuteBlock<Block>

	for Executive<System, Block, Context, UnsignedValidator, AllPalletsWithSystem, COnRuntimeUpgrade>

where

	Block::Extrinsic: Checkable<Context> + Codec,

	CheckedOf<Block::Extrinsic, Context>: Applyable + GetDispatchInfo,

	CallOf<Block::Extrinsic, Context>:

		Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

	OriginOf<Block::Extrinsic, Context>: From<Option<System::AccountId>>,

	UnsignedValidator: ValidateUnsigned<Call = CallOf<Block::Extrinsic, Context>>,

{

}

#[cfg(feature = "try-runtime")]

impl<

		System: frame_system::Config + EnsureInherentsAreFirst<Block>,

		Block: traits::Block<

			Header = frame_system::pallet_prelude::HeaderFor<System>,

			Hash = System::Hash,

		>,

		Context: Default,

		UnsignedValidator,

		AllPalletsWithSystem: OnRuntimeUpgrade

			+ BeforeAllRuntimeMigrations

			+ OnInitialize<BlockNumberFor<System>>

			+ OnIdle<BlockNumberFor<System>>

			+ OnFinalize<BlockNumberFor<System>>

			+ OffchainWorker<BlockNumberFor<System>>

			+ OnPoll<BlockNumberFor<System>>

			+ TryState<BlockNumberFor<System>>

			+ TryDecodeEntireStorage,

		COnRuntimeUpgrade: OnRuntimeUpgrade,

	> Executive<System, Block, Context, UnsignedValidator, AllPalletsWithSystem, COnRuntimeUpgrade>

where

	Block::Extrinsic: Checkable<Context> + Codec,

	CheckedOf<Block::Extrinsic, Context>: Applyable + GetDispatchInfo,

	CallOf<Block::Extrinsic, Context>:

		Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

	OriginOf<Block::Extrinsic, Context>: From<Option<System::AccountId>>,

	UnsignedValidator: ValidateUnsigned<Call = CallOf<Block::Extrinsic, Context>>,

{

	/// Execute given block, but don't as strict is the normal block execution.

	///

	/// Some checks can be disabled via:

	///

	/// - `state_root_check`

	/// - `signature_check`

	///

	/// Should only be used for testing ONLY.

			target: LOG_TARGET,

			state_root_check,

			signature_check,

			select,

		);

			// skip signature verification.

			} else {

		// Apply extrinsics:

					e,

					err,

				);

		}

		// In this case there were no transactions to trigger this state transition:

		// post-extrinsics book-keeping

			}

				);

			);

		}

			target: LOG_TARGET,

		);

	/// Execute all Migrations of this runtime.

	///

	/// The `checks` param determines whether to execute `pre/post_upgrade` and `try_state` hooks.

	///

	/// [`frame_system::LastRuntimeUpgrade`] is set to the current runtime version after

	/// migrations execute. This is important for idempotency checks, because some migrations use

	/// this value to determine whether or not they should execute.

		// Check all storage invariants:

	/// Logs the result of trying to decode the entire state.

					target: LOG_TARGET,

					bytes

				);

			},

					target: LOG_TARGET,

				);

					// We log the short version to `error` and then the full debug info to `debug`:

				}

			},

		}

}

impl<

		System: frame_system::Config + EnsureInherentsAreFirst<Block>,

		Block: traits::Block<

			Header = frame_system::pallet_prelude::HeaderFor<System>,

			Hash = System::Hash,

		>,

		Context: Default,

		UnsignedValidator,

		AllPalletsWithSystem: OnRuntimeUpgrade

			+ BeforeAllRuntimeMigrations

			+ OnInitialize<BlockNumberFor<System>>

			+ OnIdle<BlockNumberFor<System>>

			+ OnFinalize<BlockNumberFor<System>>

			+ OffchainWorker<BlockNumberFor<System>>

			+ OnPoll<BlockNumberFor<System>>,

		COnRuntimeUpgrade: OnRuntimeUpgrade,

	> Executive<System, Block, Context, UnsignedValidator, AllPalletsWithSystem, COnRuntimeUpgrade>

where

	Block::Extrinsic: Checkable<Context> + Codec,

	CheckedOf<Block::Extrinsic, Context>: Applyable + GetDispatchInfo,

	CallOf<Block::Extrinsic, Context>:

		Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,

	OriginOf<Block::Extrinsic, Context>: From<Option<System::AccountId>>,

	UnsignedValidator: ValidateUnsigned<Call = CallOf<Block::Extrinsic, Context>>,

{

	/// Execute all `OnRuntimeUpgrade` of this runtime, and return the aggregate weight.

	/// Start the execution of a particular block.

		} else {

		}

	/// Returns if the runtime has been upgraded, based on [`frame_system::LastRuntimeUpgrade`].

	/// Returns the number of inherents in the block.

		);

		}

	/// Actually execute all transitions for `block`.

			// Execute `on_runtime_upgrade` and `on_initialize`.

			let mode = Self::initialize_block(block.header());

			let num_inherents = Self::initial_checks(&block) as usize;

			let (header, extrinsics) = block.deconstruct();

			let num_extrinsics = extrinsics.len();

			if mode == ExtrinsicInclusionMode::OnlyInherents && num_extrinsics > num_inherents {

				// Invalid block

				panic!("Only inherents are allowed in this block")

			}

			Self::apply_extrinsics(extrinsics.into_iter());

			// In this case there were no transactions to trigger this state transition:

			if !<frame_system::Pallet<System>>::inherents_applied() {

				defensive_assert!(num_inherents == num_extrinsics);

				Self::inherents_applied();

			}

			<frame_system::Pallet<System>>::note_finished_extrinsics();

			<System as frame_system::Config>::PostTransactions::post_transactions();

			Self::on_idle_hook(*header.number());

			Self::on_finalize_hook(*header.number());

			Self::final_checks(&header);

		}

	/// Logic that runs directly after inherent application.

	///

	/// It advances the Multi-Block-Migrations or runs the `on_poll` hook.

	/// Execute given extrinsics.

	/// Finalize the block - it is up the caller to ensure that all header fields are valid

	/// except state-root.

	// Note: Only used by the block builder - not Executive itself.

		// In this case there were no transactions to trigger this state transition:

	/// Run the `on_idle` hook of all pallet, but only if there is weight remaining and there are no

	/// ongoing MBMs.

	/// Run the `on_finalize` hook of all pallet.

	/// 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.

		// We use the dedicated `is_inherent` check here, since just relying on `Mandatory` dispatch

		// class does not capture optional inherents.

		// Verify that the signature is good.

		// 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).

		// AUDIT: Under no circumstances may this function panic from here onwards.

		// Mandatory(inherents) are not allowed to fail.

		//

		// The entire block should be discarded if an inherent fails to apply. Otherwise

		// it may open an attack vector.

		// remove temporaries

		);

		}

		// check storage root.

		);

	/// 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.

		use sp_tracing::{enter_span, within_span};

		};

			uxt.check(&Default::default())

			xt.get_dispatch_info()

		};

			xt.validate::<UnsignedValidator>(source, &dispatch_info, encoded_len)

		}

	/// Start an offchain worker and generate extrinsics.

}