Macro polkadot_sdk_frame::runtime::prelude::construct_runtime

construct_runtime!() { /* proc-macro */ }

Macro to amalgamate the runtime into struct Runtime.

Consider using the new version of this frame_construct_runtime. Construct a runtime, with the given name and the given pallets.

NOTE: A new version of this macro is available at frame_support::runtime. This macro will soon be deprecated. Please use the new macro instead.

The parameters here are specific types for Block, NodeBlock, and UncheckedExtrinsic and the pallets that are used by the runtime. Block is the block type that is used in the runtime and NodeBlock is the block type that is used in the node. For instance they can differ in the extrinsics type.

Example:

construct_runtime!(
    pub enum Runtime where
        Block = Block,
        NodeBlock = node::Block,
        UncheckedExtrinsic = UncheckedExtrinsic
    {
        System: frame_system::{Pallet, Call, Event<T>, Config<T>} = 0,
        Test: path::to::test::{Pallet, Call} = 1,

        // Pallets with instances.
        Test2_Instance1: test2::<Instance1>::{Pallet, Call, Storage, Event<T, I>, Config<T, I>, Origin<T, I>},
        Test2_DefaultInstance: test2::{Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>} = 4,

        // Pallets declared with `pallet` attribute macro: no need to define the parts
        Test3_Instance1: test3::<Instance1>,
        Test3_DefaultInstance: test3,

        // with `exclude_parts` keyword some part can be excluded.
        Test4_Instance1: test4::<Instance1> exclude_parts { Call, Origin },
        Test4_DefaultInstance: test4 exclude_parts { Storage },

        // with `use_parts` keyword, a subset of the pallet parts can be specified.
        Test4_Instance1: test4::<Instance1> use_parts { Pallet, Call},
        Test4_DefaultInstance: test4 use_parts { Pallet },
    }
)

Each pallet is declared as such:

• Identifier: name given to the pallet that uniquely identifies it.

• :: colon separator

• path::to::pallet: identifiers separated by colons which declare the path to a pallet definition.

• ::<InstanceN> optional: specify the instance of the pallet to use. If not specified it will use the default instance (or the only instance in case of non-instantiable pallets).

• ::{ Part1, Part2<T>, .. } optional if pallet declared with frame_support::pallet: Comma separated parts declared with their generic. If a pallet is declared with frame_support::pallet macro then the parts can be automatically derived if not explicitly provided. We provide support for the following module parts in a pallet:

  • Pallet - Required for all pallets
  • Call - If the pallet has callable functions
  • Storage - If the pallet uses storage
  • Event or Event<T> (if the event is generic) - If the pallet emits events
  • Origin or Origin<T> (if the origin is generic) - If the pallet has instantiable origins
  • Config or Config<T> (if the config is generic) - If the pallet builds the genesis storage with GenesisConfig
  • Inherent - If the pallet provides/can check inherents.
  • ValidateUnsigned - If the pallet validates unsigned extrinsics.

  It is important to list these parts here to export them correctly in the metadata or to make the pallet usable in the runtime.

• exclude_parts { Part1, Part2 } optional: comma separated parts without generics. I.e. one of Pallet, Call, Storage, Event, Origin, Config, Inherent, ValidateUnsigned. It is incompatible with use_parts. This specifies the part to exclude. In order to select subset of the pallet parts.

  For example excluding the part Call can be useful if the runtime doesn’t want to make the pallet calls available.

• use_parts { Part1, Part2 } optional: comma separated parts without generics. I.e. one of Pallet, Call, Storage, Event, Origin, Config, Inherent, ValidateUnsigned. It is incompatible with exclude_parts. This specifies the part to use. In order to select a subset of the pallet parts.

  For example not using the part Call can be useful if the runtime doesn’t want to make the pallet calls available.

• = $n optional: number to define at which index the pallet variants in OriginCaller, Call and Event are encoded, and to define the ModuleToIndex value.

  if = $n is not given, then index is resolved in the same way as fieldless enum in Rust (i.e. incrementally from previous index):

  pallet1 .. = 2,
  pallet2 .., // Here pallet2 is given index 3
  pallet3 .. = 0,
  pallet4 .., // Here pallet4 is given index 1
  

Note

The population of the genesis storage depends on the order of pallets. So, if one of your pallets depends on another pallet, the pallet that is depended upon needs to come before the pallet depending on it.

Type definitions

• The macro generates a type alias for each pallet to their Pallet. E.g. type System = frame_system::Pallet<Runtime>