Attribute Macro frame_support::pallet

source · [−]

#[pallet]

Expand description

pallet attribute macro allows to define a pallet to be used in construct_runtime!.

It is define by a module item:

#[pallet]
pub mod pallet {
...
}

Inside the module the macro will parse item with the attribute: #[pallet::*], some attributes are mandatory, some other optional.

The attribute are explained with the syntax of non instantiable pallets, to see how pallet with instance work see below example.

Note various type can be automatically imported using pallet_prelude in frame_support and frame_system:

#[pallet]
pub mod pallet {
		use frame_support::pallet_prelude::*;
		use frame_system::pallet_prelude::*;
		...
}

Config trait: `#[pallet::config]` mandatory

The trait defining generics of the pallet.

Item must be defined as

#[pallet::config]
pub trait Config: frame_system::Config + $optionally_some_other_supertraits
$optional_where_clause
{
...
}

I.e. a regular trait definition named Config, with supertrait frame_system::Config, optionally other supertrait and where clause.

The associated type Event is reserved, if defined it must bounds From<Event> and IsType<<Self as frame_system::Config>::Event>, see #[pallet::event] for more information.

To put Get associated type into metadatas, use the attribute #[pallet::constant], e.g.:

#[pallet::config]
pub trait Config: frame_system::Config {
		#[pallet::constant]
		type Foo: Get<u32>;
}

To bypass the frame_system::Config supertrait check, use the attribute #[pallet::disable_frame_system_supertrait_check], e.g.:

#[pallet::config]
#[pallet::disable_frame_system_supertrait_check]
pub trait Config: pallet_timestamp::Config {}

Macro expansion:

The macro expand pallet constant metadata with the information given by #[pallet::constant].

Pallet struct placeholder: `#[pallet::pallet]` mandatory

The placeholder struct, on which is implemented pallet informations.

Item must be defined as followed:

#[pallet::pallet]
pub struct Pallet<T>(_);

I.e. a regular struct definition named Pallet, with generic T and no where clause.

To generate a Store trait associating all storages, use the attribute #[pallet::generate_store($vis trait Store)], e.g.:

#[pallet::pallet]
#[pallet::generate_store(pub(super) trait Store)]
pub struct Pallet<T>(_);

More precisely the store trait contains an associated type for each storage. It is implemented for Pallet allowing to access the storage from pallet struct.

Thus when defining a storage named Foo, it can later be accessed from Pallet using <Pallet as Store>::Foo.

To generate the full storage info (used for PoV calculation) use the attribute #[pallet::generate_storage_info], e.g.:

#[pallet::pallet]
#[pallet::generate_storage_info]
pub struct Pallet<T>(_);

This require all storage to implement the trait traits::StorageInfoTrait, thus all keys and value types must bound pallet_prelude::MaxEncodedLen. Some individual storage can opt-out from this constraint by using #[pallet::unbounded], see #[pallet::storage] documentation.

As the macro implements traits::GetStorageVersion, the current storage version needs to be communicated to the macro. This can be done by using the storage_version attribute:

const STORAGE_VERSION: StorageVersion = StorageVersion::new(5);

#[pallet::pallet]
#[pallet::storage_version(STORAGE_VERSION)]
pub struct Pallet<T>(_);

If not present, the current storage version is set to the default value.

Macro expansion:

The macro add this attribute to the struct definition:

#[derive(
	frame_support::CloneNoBound,
	frame_support::EqNoBound,
	frame_support::PartialEqNoBound,
	frame_support::RuntimeDebugNoBound,
)]

and replace the type _ by PhantomData<T>.

It implements on pallet:

traits::GetStorageVersion
traits::OnGenesis: contains some logic to write pallet version into storage.
PalletErrorTypeInfo: provides the type information for the pallet error, if defined.

It declares type Module type alias for Pallet, used by construct_runtime.

It implements traits::PalletInfoAccess on Pallet to ease access to pallet informations given by frame_support::traits::PalletInfo. (The implementation uses the associated type frame_system::Config::PalletInfo).

It implements traits::StorageInfoTrait on Pallet which give information about all storages.

If the attribute generate_store is set then the macro creates the trait Store and implements it on Pallet.

If the attribute set_storage_max_encoded_len is set then the macro call traits::StorageInfoTrait for each storage in the implementation of traits::StorageInfoTrait for the pallet. Otherwise it implements traits::StorageInfoTrait for the pallet using the traits::PartialStorageInfoTrait implementation of storages.

Hooks: `#[pallet::hooks]` optional

Implementation of Hooks on Pallet allowing to define some specific pallet logic.

Item must be defined as

#[pallet::hooks]
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> $optional_where_clause {
}

I.e. a regular trait implementation with generic bound: T: Config, for the trait Hooks<BlockNumberFor<T>> (they are defined in preludes), for the type Pallet<T> and with an optional where clause.

If no #[pallet::hooks] exists, then a default implementation corresponding to the following code is automatically generated:

#[pallet::hooks]
impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}

Macro expansion:

The macro implements the traits OnInitialize, OnIdle, OnFinalize, OnRuntimeUpgrade, OffchainWorker, IntegrityTest using Hooks implementation.

NOTE: OnRuntimeUpgrade is implemented with Hooks::on_runtime_upgrade and some additional logic. E.g. logic to write pallet version into storage.

NOTE: The macro also adds some tracing logic when implementing the above traits. The following hooks emit traces: on_initialize, on_finalize and on_runtime_upgrade.

Call: `#[pallet::call]` optional

Implementation of pallet dispatchables.

Item must be defined as:

#[pallet::call]
impl<T: Config> Pallet<T> {
	/// $some_doc
	#[pallet::weight($ExpressionResultingInWeight)]
	pub fn $fn_name(
		origin: OriginFor<T>,
		$some_arg: $some_type,
		// or with compact attribute: #[pallet::compact] $some_arg: $some_type,
		...
	) -> DispatchResultWithPostInfo { // or `-> DispatchResult`
		...
	}
	...
}

I.e. a regular type implementation, with generic T: Config, on type Pallet<T>, with optional where clause.

Each dispatchable needs to define a weight with #[pallet::weight($expr)] attribute, the first argument must be origin: OriginFor<T>, compact encoding for argument can be used using #[pallet::compact], function must return DispatchResultWithPostInfo or DispatchResult.

All arguments must implement Debug, PartialEq, Eq, Decode, Encode, Clone. For ease of use, bound the trait Member available in frame_support::pallet_prelude.

If no #[pallet::call] exists, then a default implementation corresponding to the following code is automatically generated:

#[pallet::call]
impl<T: Config> Pallet<T> {}

WARNING: modifying dispatchables, changing their order, removing some must be done with care. Indeed this will change the outer runtime call type (which is an enum with one variant per pallet), this outer runtime call can be stored on-chain (e.g. in pallet-scheduler). Thus migration might be needed.

Macro expansion

The macro create an enum Call with one variant per dispatchable. This enum implements: Clone, Eq, PartialEq, Debug (with stripped implementation in not("std")), Encode, Decode, GetDispatchInfo, GetCallName, UnfilteredDispatchable.

The macro implement on Pallet, the Callable trait and a function call_functions which returns the dispatchable metadatas.

Extra constants: `#[pallet::extra_constants]` optional

Allow to define some extra constants to put into constant metadata.

Item must be defined as:

#[pallet::extra_constants]
impl<T: Config> Pallet<T> where $optional_where_clause {
	/// $some_doc
	$vis fn $fn_name() -> $some_return_type {
		...
	}
	...
}

I.e. a regular rust implement block with some optional where clause and functions with 0 args, 0 generics, and some return type.

Macro expansion

The macro add some extra constant to pallet constant metadata.

Error: `#[pallet::error]` optional

Allow to define an error type to be return from dispatchable on error. This error type informations are put into metadata.

Item must be defined as:

#[pallet::error]
pub enum Error<T> {
	/// $some_optional_doc
	$SomeFieldLessVariant,
	...
}

I.e. a regular rust enum named Error, with generic T and fieldless variants. The generic T mustn’t bound anything and where clause is not allowed. But bounds and where clause shouldn’t be needed for any usecase.

Macro expansion

The macro implements Debug trait and functions as_u8 using variant position, and as_str using variant doc.

The macro implements From<Error<T>> for &'static str. The macro implements From<Error<T>> for DispatchError.

Event: `#[pallet::event]` optional

Allow to define pallet events, pallet events are stored in the block when they deposited (and removed in next block).

Item is defined as:

#[pallet::event]
#[pallet::generate_deposit($visibility fn deposit_event)] // Optional
pub enum Event<$some_generic> $optional_where_clause {
	/// Some doc
	$SomeName($SomeType, $YetanotherType, ...),
	...
}

I.e. an enum (with named or unnamed fields variant), named Event, with generic: none or T or T: Config, and optional where clause.

Each field must implement Clone, Eq, PartialEq, Encode, Decode, and Debug (on std only). For ease of use, bound the trait Member available in frame_support::pallet_prelude.

The attribute #[pallet::generate_deposit($visibility fn deposit_event)] generate a helper function on Pallet to deposit event.

NOTE: For instantiable pallet, event must be generic over T and I.

Macro expansion:

Macro will add on enum Event the attributes:

#[derive(frame_support::CloneNoBound)],
#[derive(frame_support::EqNoBound)],
#[derive(frame_support::PartialEqNoBound)],
#[derive(codec::Encode)],
#[derive(codec::Decode)],
#[derive(frame_support::RuntimeDebugNoBound)]

Macro implements From<Event<..>> for ().

Macro implements metadata function on Event returning the EventMetadata.

If #[pallet::generate_deposit] then macro implement fn deposit_event on Pallet.

Storage: `#[pallet::storage]` optional

Allow to define some abstract storage inside runtime storage and also set its metadata. This attribute can be used multiple times.

Item is defined as:

#[pallet::storage]
#[pallet::getter(fn $getter_name)] // optional
$vis type $StorageName<$some_generic> $optional_where_clause
	= $StorageType<$generic_name = $some_generics, $other_name = $some_other, ...>;

or with unnamed generic

#[pallet::storage]
#[pallet::getter(fn $getter_name)] // optional
$vis type $StorageName<$some_generic> $optional_where_clause
	= $StorageType<_, $some_generics, ...>;

I.e. it must be a type alias, with generics: T or T: Config, aliased type must be one of StorageValue, StorageMap or StorageDoubleMap (defined in frame_support). The generic arguments of the storage type can be given in two manner: named and unnamed. For named generic argument: the name for each argument is the one as define on the storage struct:

pallet_prelude::StorageValue expect Value and optionally QueryKind and OnEmpty,
pallet_prelude::StorageMap expect Hasher, Key, Value and optionally QueryKind and OnEmpty,
pallet_prelude::CountedStorageMap expect Hasher, Key, Value and optionally QueryKind and OnEmpty,
pallet_prelude::StorageDoubleMap expect Hasher1, Key1, Hasher2, Key2, Value and optionally QueryKind and OnEmpty.

For unnamed generic argument: Their first generic must be _ as it is replaced by the macro and other generic must declared as a normal declaration of type generic in rust.

The Prefix generic written by the macro is generated using PalletInfo::name::<Pallet<..>>() and the name of the storage type. E.g. if runtime names the pallet “MyExample” then the storage type Foo<T> = ... use the prefix: Twox128(b"MyExample") ++ Twox128(b"Foo").

For the CountedStorageMap variant, the Prefix also implements CountedStorageMapInstance. It associate a CounterPrefix, which is implemented same as above, but the storage prefix is prepend with "CounterFor". E.g. if runtime names the pallet “MyExample” then the storage type Foo<T> = CountedStorageaMap<...> will store its counter at the prefix: Twox128(b"MyExample") ++ Twox128(b"CounterForFoo").

E.g:

#[pallet::storage]
pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;

In this case the final prefix used by the map is Twox128(b"MyExample") ++ Twox128(b"OtherName").

The optional attribute #[pallet::getter(fn $my_getter_fn_name)] allows to define a getter function on Pallet.

The optional attribute #[pallet::storage_prefix = "SomeName"] allow to define the storage prefix to use, see how Prefix generic is implemented above.

E.g:

#[pallet::storage]
#[pallet::storage_prefix = "foo"]
#[pallet::getter(fn my_storage)]
pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;

or

#[pallet::storage]
#[pallet::getter(fn my_storage)]
pub(super) type MyStorage<T> = StorageMap<_, Blake2_128Concat, u32, u32>;

The optional attribute #[pallet::unbounded] allows to declare the storage as unbounded. When implementating the storage info (when #[pallet::generate_storage_info] is specified on the pallet struct placeholder), the size of the storage will be declared as unbounded. This can be useful for storage which can never go into PoV (Proof of Validity).

The optional attributes #[cfg(..)] allow conditional compilation for the storage.

E.g:

#[cfg(feature = "my-feature")]
#[pallet::storage]
pub(super) type MyStorage<T> = StorageValue<Value = u32>;

All the cfg attributes are automatically copied to the items generated for the storage, i.e. the getter, storage prefix, and the metadata element etc.

NOTE: If the QueryKind generic parameter is still generic at this stage or is using some type alias then the generation of the getter might fail. In this case the getter can be implemented manually.

NOTE: The generic Hasher must implement the StorageHasher trait (or the type is not usable at all). We use StorageHasher::METADATA for the metadata of the hasher of the storage item. Thus generic hasher is supported.

Macro expansion

For each storage item the macro generates a struct named _GeneratedPrefixForStorage$NameOfStorage, and implements StorageInstance on it using the pallet and storage name. It then uses it as the first generic of the aliased type. For CountedStorageMap, CountedStorageMapInstance is implemented, and another similar struct is generated.

For named generic, the macro will reorder the generics, and remove the names.

The macro implements the function storage_metadata on Pallet implementing the metadata for all storage items based on their kind:

for a storage value, the type of the value is copied into the metadata
for a storage map, the type of the values and the key’s type is copied into the metadata
for a storage double map, the type of the values, and the types of key1 and key2 are copied into the metadata.

Type value: `#[pallet::type_value]` optional

Helper to define a struct implementing Get trait. To ease use of storage types. This attribute can be used multiple time.

Item is defined as

#[pallet::type_value]
fn $MyDefaultName<$some_generic>() -> $default_type $optional_where_clause { $expr }

I.e.: a function definition with generics none or T: Config and a returned type.

E.g.:

#[pallet::type_value]
fn MyDefault<T: Config>() -> T::Balance { 3.into() }

NOTE: This attribute is meant to be used alongside #[pallet::storage] to defined some specific default value in storage.

Macro expansion

Macro renames the function to some internal name, generate a struct with the original name of the function and its generic, and implement Get<$ReturnType> by calling the user defined function.

Genesis config: `#[pallet::genesis_config]` optional

Allow to define the genesis configuration of the pallet.

Item is defined as either an enum or a struct. It needs to be public and implement trait GenesisBuild with #[pallet::genesis_build]. The type generics is constrained to be either none, or T or T: Config.

E.g:

#[pallet::genesis_config]
pub struct GenesisConfig<T: Config> {
	_myfield: BalanceOf<T>,
}

Macro expansion

Macro will add the following attribute on it:

#[cfg(feature = "std")]
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
#[serde(bound(serialize = ""))]
#[serde(bound(deserialize = ""))]

Genesis build: `#[pallet::genesis_build]` optional

Allow to define how genesis_configuration is built.

Item is defined as

#[pallet::genesis_build]
impl<T: Config> GenesisBuild<T> for GenesisConfig<$maybe_generics> {
	fn build(&self) { $expr }
}

I.e. a rust trait implementation with generic T: Config, of trait GenesisBuild<T> on type GenesisConfig with generics none or T.

E.g.:

#[pallet::genesis_build]
impl<T: Config> GenesisBuild<T> for GenesisConfig {
	fn build(&self) {}
}

Macro expansion

Macro will add the following attribute on it:

#[cfg(feature = "std")]

Macro will implement sp_runtime::BuildModuleGenesisStorage using () as second generic for non-instantiable pallets.

Inherent: `#[pallet::inherent]` optional

Allow the pallet to provide some inherent:

Item is defined as:

#[pallet::inherent]
impl<T: Config> ProvideInherent for Pallet<T> {
	// ... regular trait implementation
}

I.e. a trait implementation with bound T: Config, of trait ProvideInherent for type Pallet<T>, and some optional where clause.

Macro expansion

Macro make currently no use of this information, but it might use this information in the future to give information directly to construct_runtime.

Validate unsigned: `#[pallet::validate_unsigned]` optional

Allow the pallet to validate some unsigned transaction:

Item is defined as:

#[pallet::validate_unsigned]
impl<T: Config> ValidateUnsigned for Pallet<T> {
	// ... regular trait implementation
}

I.e. a trait implementation with bound T: Config, of trait ValidateUnsigned for type Pallet<T>, and some optional where clause.

NOTE: There is also sp_runtime::traits::SignedExtension that can be used to add some specific logic for transaction validation.

Macro expansion

Macro make currently no use of this information, but it might use this information in the future to give information directly to construct_runtime.

Origin: `#[pallet::origin]` optional

Allow to define some origin for the pallet.

Item must be either a type alias or an enum or a struct. It needs to be public.

E.g.:

#[pallet::origin]
pub struct Origin<T>(PhantomData<(T)>);

WARNING: modifying origin changes the outer runtime origin. This outer runtime origin can be stored on-chain (e.g. in pallet-scheduler), thus any change must be done with care as it might require some migration.

NOTE: for instantiable pallet, origin must be generic over T and I.

General notes on instantiable pallet

An instantiable pallet is one where Config is generic, i.e. Config<I>. This allow runtime to implement multiple instance of the pallet, by using different type for the generic. This is the sole purpose of the generic I. But because PalletInfo requires Pallet placeholder to be static it is important to bound 'static whenever PalletInfo can be used. And in order to have instantiable pallet usable as a regular pallet without instance, it is important to bound = () on every types.

Thus impl bound look like impl<T: Config<I>, I: 'static>, and types look like SomeType<T, I=()> or SomeType<T: Config<I>, I: 'static = ()>.

Example for pallet without instance.

pub use pallet::*; // reexport in crate namespace for `construct_runtime!`

#[frame_support::pallet]
// NOTE: The name of the pallet is provided by `construct_runtime` and is used as
// the unique identifier for the pallet's storage. It is not defined in the pallet itself.
pub mod pallet {
	use frame_support::pallet_prelude::*; // Import various types used in the pallet definition
	use frame_system::pallet_prelude::*; // Import some system helper types.

	type BalanceOf<T> = <T as Config>::Balance;

	// Define the generic parameter of the pallet
	// The macro parses `#[pallet::constant]` attributes and uses them to generate metadata
	// for the pallet's constants.
	#[pallet::config]
	pub trait Config: frame_system::Config {
		#[pallet::constant] // put the constant in metadata
		type MyGetParam: Get<u32>;
		type Balance: Parameter + From<u8>;
		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
	}

	// Define some additional constant to put into the constant metadata.
	#[pallet::extra_constants]
	impl<T: Config> Pallet<T> {
		/// Some description
		fn exra_constant_name() -> u128 { 4u128 }
	}

	// Define the pallet struct placeholder, various pallet function are implemented on it.
	#[pallet::pallet]
	#[pallet::generate_store(pub(super) trait Store)]
	pub struct Pallet<T>(_);

	// Implement the pallet hooks.
	#[pallet::hooks]
	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
			unimplemented!();
		}

		// can implement also: on_finalize, on_runtime_upgrade, offchain_worker, ...
		// see `Hooks` trait
	}

	// Declare Call struct and implement dispatchables.
	//
	// WARNING: Each parameter used in functions must implement: Clone, Debug, Eq, PartialEq,
	// Codec.
	//
	// The macro parses `#[pallet::compact]` attributes on function arguments and implements
	// the `Call` encoding/decoding accordingly.
	#[pallet::call]
	impl<T: Config> Pallet<T> {
		/// Doc comment put in metadata
		#[pallet::weight(0)] // Defines weight for call (function parameters are in scope)
		pub fn toto(
			origin: OriginFor<T>,
			#[pallet::compact] _foo: u32,
		) -> DispatchResultWithPostInfo {
			let _ = origin;
			unimplemented!();
		}
	}

	// Declare the pallet `Error` enum (this is optional).
	// The macro generates error metadata using the doc comment on each variant.
	#[pallet::error]
	pub enum Error<T> {
		/// doc comment put into metadata
		InsufficientProposersBalance,
	}

	// Declare pallet Event enum (this is optional).
	//
	// WARNING: Each type used in variants must implement: Clone, Debug, Eq, PartialEq, Codec.
	//
	// The macro generates event metadata, and derive Clone, Debug, Eq, PartialEq and Codec
	#[pallet::event]
	// Generate a funciton on Pallet to deposit an event.
	#[pallet::generate_deposit(pub(super) fn deposit_event)]
	pub enum Event<T: Config> {
		/// doc comment put in metadata
		// `<T as frame_system::Config>::AccountId` is not defined in metadata list, the last
		// Thus the metadata is `<T as frame_system::Config>::AccountId`.
		Proposed(<T as frame_system::Config>::AccountId),
		/// doc
		// here metadata will be `Balance` as define in metadata list
		Spending(BalanceOf<T>),
		// here metadata will be `Other` as define in metadata list
		Something(u32),
	}

	// Define a struct which implements `frame_support::traits::Get<T::Balance>` (optional).
	#[pallet::type_value]
	pub(super) fn MyDefault<T: Config>() -> T::Balance { 3.into() }

	// Declare a storage item. Any amount of storage items can be declared (optional).
	//
	// Is expected either `StorageValue`, `StorageMap` or `StorageDoubleMap`.
	// The macro generates the prefix type and replaces the first generic `_`.
	//
	// The macro expands the metadata for the storage item with the type used:
	// * for a storage value the type of the value is copied into the metadata
	// * for a storage map the type of the values and the type of the key is copied into the metadata
	// * for a storage double map the types of the values and keys are copied into the
	//   metadata.
	//
	// NOTE: The generic `Hasher` must implement the `StorageHasher` trait (or the type is not
	// usable at all). We use [`StorageHasher::METADATA`] for the metadata of the hasher of the
	// storage item. Thus generic hasher is supported.
	#[pallet::storage]
	pub(super) type MyStorageValue<T: Config> =
		StorageValue<Value = T::Balance, QueryKind = ValueQuery, OnEmpty = MyDefault<T>>;

	// Another storage declaration
	#[pallet::storage]
	#[pallet::getter(fn my_storage)]
	#[pallet::storage_prefix = "SomeOtherName"]
	pub(super) type MyStorage<T> =
		StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;

	// Declare the genesis config (optional).
	//
	// The macro accepts either a struct or an enum; it checks that generics are consistent.
	//
	// Type must implement the `Default` trait.
	#[pallet::genesis_config]
	#[derive(Default)]
	pub struct GenesisConfig {
		_myfield: u32,
	}

	// Declare genesis builder. (This is need only if GenesisConfig is declared)
	#[pallet::genesis_build]
	impl<T: Config> GenesisBuild<T> for GenesisConfig {
		fn build(&self) {}
	}

	// Declare a pallet origin (this is optional).
	//
	// The macro accept type alias or struct or enum, it checks generics are consistent.
	#[pallet::origin]
	pub struct Origin<T>(PhantomData<T>);

	// Declare validate_unsigned implementation (this is optional).
	#[pallet::validate_unsigned]
	impl<T: Config> ValidateUnsigned for Pallet<T> {
		type Call = Call<T>;
		fn validate_unsigned(
			source: TransactionSource,
			call: &Self::Call
		) -> TransactionValidity {
			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
		}
	}

	// Declare inherent provider for pallet (this is optional).
	#[pallet::inherent]
	impl<T: Config> ProvideInherent for Pallet<T> {
		type Call = Call<T>;
		type Error = InherentError;

		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;

		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
			unimplemented!();
		}

		fn is_inherent(_call: &Self::Call) -> bool {
			unimplemented!();
		}
	}

	// Regular rust code needed for implementing ProvideInherent trait

	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
	#[cfg_attr(feature = "std", derive(codec::Decode))]
	pub enum InherentError {
	}

	impl sp_inherents::IsFatalError for InherentError {
		fn is_fatal_error(&self) -> bool {
			unimplemented!();
		}
	}

	pub const INHERENT_IDENTIFIER: sp_inherents::InherentIdentifier = *b"testpall";
}

Example for pallet with instance.

pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
	use frame_support::pallet_prelude::*;
	use frame_system::pallet_prelude::*;

	type BalanceOf<T, I = ()> = <T as Config<I>>::Balance;

	#[pallet::config]
	pub trait Config<I: 'static = ()>: frame_system::Config {
		#[pallet::constant]
		type MyGetParam: Get<u32>;
		type Balance: Parameter + From<u8>;
		type Event: From<Event<Self, I>> + IsType<<Self as frame_system::Config>::Event>;
	}

	#[pallet::extra_constants]
	impl<T: Config<I>, I: 'static> Pallet<T, I> {
		/// Some description
		fn exra_constant_name() -> u128 { 4u128 }
	}

	#[pallet::pallet]
	#[pallet::generate_store(pub(super) trait Store)]
	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);

	#[pallet::hooks]
	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
	}

	#[pallet::call]
	impl<T: Config<I>, I: 'static> Pallet<T, I> {
		/// Doc comment put in metadata
		#[pallet::weight(0)]
		pub fn toto(origin: OriginFor<T>, #[pallet::compact] _foo: u32) -> DispatchResultWithPostInfo {
			let _ = origin;
			unimplemented!();
		}
	}

	#[pallet::error]
	pub enum Error<T, I = ()> {
		/// doc comment put into metadata
		InsufficientProposersBalance,
	}

	#[pallet::event]
	#[pallet::generate_deposit(pub(super) fn deposit_event)]
	pub enum Event<T: Config<I>, I: 'static = ()> {
		/// doc comment put in metadata
		Proposed(<T as frame_system::Config>::AccountId),
		/// doc
		Spending(BalanceOf<T, I>),
		Something(u32),
	}

	#[pallet::type_value]
	pub(super) fn MyDefault<T: Config<I>, I: 'static>() -> T::Balance { 3.into() }

	#[pallet::storage]
	pub(super) type MyStorageValue<T: Config<I>, I: 'static = ()> =
		StorageValue<Value = T::Balance, QueryKind = ValueQuery, OnEmpty = MyDefault<T, I>>;

	#[pallet::storage]
	#[pallet::getter(fn my_storage)]
	#[pallet::storage_prefix = "SomeOtherName"]
	pub(super) type MyStorage<T, I = ()> =
		StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;

	#[pallet::genesis_config]
	#[derive(Default)]
	pub struct GenesisConfig {
		_myfield: u32,
	}

	#[pallet::genesis_build]
	impl<T: Config<I>, I: 'static> GenesisBuild<T, I> for GenesisConfig {
		fn build(&self) {}
	}

	#[pallet::origin]
	pub struct Origin<T, I = ()>(PhantomData<(T, I)>);

	#[pallet::validate_unsigned]
	impl<T: Config<I>, I: 'static> ValidateUnsigned for Pallet<T, I> {
		type Call = Call<T, I>;
		fn validate_unsigned(
			source: TransactionSource,
			call: &Self::Call
		) -> TransactionValidity {
			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
		}
	}

	#[pallet::inherent]
	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I> {
		type Call = Call<T, I>;
		type Error = InherentError;

		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;

		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
			unimplemented!();
		}

		fn is_inherent(_call: &Self::Call) -> bool {
			unimplemented!();
		}
	}

	// Regular rust code needed for implementing ProvideInherent trait

	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
	#[cfg_attr(feature = "std", derive(codec::Decode))]
	pub enum InherentError {
	}

	impl sp_inherents::IsFatalError for InherentError {
		fn is_fatal_error(&self) -> bool {
			unimplemented!();
		}
	}

	pub const INHERENT_IDENTIFIER: sp_inherents::InherentIdentifier = *b"testpall";
}

Upgrade guidelines:

Export the metadata of the pallet for later checks
- run your node with the pallet active
- query the metadata using the state_getMetadata RPC and curl, or use subsee -p <PALLET_NAME> > meta.json
generate the template upgrade for the pallet provided by decl_storage with environment variable PRINT_PALLET_UPGRADE: PRINT_PALLET_UPGRADE=1 cargo check -p my_pallet This template can be used as information it contains all information for storages, genesis config and genesis build.
reorganize pallet to have trait Config, decl_* macros, ValidateUnsigned, ProvideInherent, Origin all together in one file. Suggested order:
- Config,
- decl_module,
- decl_event,
- decl_error,
- decl_storage,
- origin,
- validate_unsigned,
- provide_inherent, so far it should compile and all be correct.

start writing the new pallet module

pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {
	use frame_support::pallet_prelude::*;
	use frame_system::pallet_prelude::*;
	use super::*;

	#[pallet::pallet]
	#[pallet::generate_store($visibility_of_trait_store trait Store)]
	// NOTE: if the visibility of trait store is private but you want to make it available
	// in super, then use `pub(super)` or `pub(crate)` to make it available in crate.
	pub struct Pallet<T>(_);
	// pub struct Pallet<T, I = ()>(PhantomData<T>); // for instantiable pallet
}

migrate Config: move trait into the module with
- all const in decl_module to #[pallet::constant]
- add bound IsType<<Self as frame_system::Config>::Event> to type Event
migrate decl_module: write:

ⓘ
```
#[pallet::hooks]
impl<T: Config> Hooks for Pallet<T> {
}
```
and write inside on_initialize, on_finalize, on_runtime_upgrade, offchain_worker, integrity_test.

then write:

ⓘ
```
#[pallet::call]
impl<T: Config> Pallet<T> {
}
```
and write inside all the calls in decl_module with a few changes in the signature:
- origin must now be written completely, e.g. origin: OriginFor<T>
- result type must be DispatchResultWithPostInfo, you need to write it and also you might need to put Ok(().into()) at the end or the function.
- #[compact] must now be written #[pallet::compact]
- #[weight = ..] must now be written #[pallet::weight(..)]
migrate event: rewrite as a simple enum under with the attribute #[pallet::event], use #[pallet::generate_deposit($vis fn deposit_event)] to generate deposit_event,
migrate error: rewrite it with attribute #[pallet::error].
migrate storage: decl_storage provide an upgrade template (see 3.). All storages, genesis config, genesis build and default implementation of genesis config can be taken from it directly.

Otherwise here is the manual process:

first migrate the genesis logic. write:

ⓘ
```
#[pallet::genesis_config]
struct GenesisConfig {
	// fields of add_extra_genesis
}
impl Default for GenesisConfig {
	// type default or default provided for fields
}
#[pallet::genesis_build]
impl<T: Config> GenesisBuild<T> for GenesisConfig {
// for instantiable pallet:
// `impl<T: Config, I: 'static> GenesisBuild<T, I> for GenesisConfig {
	fn build() {
		// The add_extra_genesis build logic
	}
}
```
for each storages, if it contains config(..) then add a fields, and make its default to the value in = ..; or the type default if none, if it contains no build then also add the logic to build the value. for each storages if it contains build(..) then add the logic to genesis_build.

NOTE: in decl_storage: is executed first the individual config and build and at the end the add_extra_genesis build

Once this is done you can migrate storage individually, a few notes:
- for private storage use pub(crate) type or pub(super) type or nothing,
- for storage with get(fn ..) use #[pallet::getter(fn ...)]
- for storage with value being Option<$something> make generic Value being $something and generic QueryKind being OptionQuery (note: this is default). Otherwise make Value the complete value type and QueryKind being ValueQuery.
- for storage with default value: = $expr; provide some specific OnEmpty generic. To do so use of #[pallet::type_value] to generate the wanted struct to put. example: MyStorage: u32 = 3u32 would be written:
  ⓘ
```
#[pallet::type_value] fn MyStorageOnEmpty() -> u32 { 3u32 }
#[pallet::storage]
pub(super) type MyStorage<T> = StorageValue<_, u32, ValueQuery, MyStorageOnEmpty>;
```
NOTE: decl_storage also generates functions assimilate_storage and build_storage directly on GenesisConfig, those are sometimes used in tests. In order not to break they can be implemented manually, one can implement those functions by calling GenesisBuild implementation.
migrate origin: move the origin to the pallet module under #[pallet::origin]
migrate validate_unsigned: move the ValidateUnsigned implementation to the pallet module under #[pallet::validate_unsigned]
migrate provide_inherent: move the ProvideInherent implementation to the pallet module under #[pallet::inherent]
rename the usage of Module to Pallet inside the crate.
migration is done, now double check migration with the checking migration guidelines.

Checking upgrade guidelines:

compare metadata. Use subsee to fetch the metadata and do a diff of the resulting json before and after migration. This checks for:
- call, names, signature, docs
- event names, docs
- error names, docs
- storage names, hasher, prefixes, default value
- error , error, constant,
manually check that:
- Origin is moved inside the macro under #[pallet::origin] if it exists
- ValidateUnsigned is moved inside the macro under #[pallet::validate_unsigned)] if it exists
- ProvideInherent is moved inside macro under #[pallet::inherent)] if it exists
- on_initialize/on_finalize/on_runtime_upgrade/offchain_worker are moved to Hooks implementation
- storages with config(..) are converted to GenesisConfig field, and their default is = $expr; if the storage have default value
- storages with build($expr) or config(..) are built in GenesisBuild::build
- add_extra_genesis fields are converted to GenesisConfig field with their correct default if specified
- add_extra_genesis build is written into GenesisBuild::build
storage items defined with pallet use the name of the pallet provided by traits::PalletInfo::name as pallet_prefix (in decl_storage, storage items used the pallet_prefix given as input of decl_storage with the syntax as Example). Thus a runtime using the pallet must be careful with this change. To handle this change:
- either ensure that the name of the pallet given to construct_runtime! is the same as the name the pallet was giving to decl_storage,
- or do a storage migration from the old prefix used to the new prefix used.
NOTE: The prefixes used by storage items are in the metadata. Thus, ensuring the metadata hasn’t changed does ensure that the pallet_prefixs used by the storage items haven’t changed.

Notes when macro fails to show proper error message spans:

Rustc loses span for some macro input. Some tips to fix it:

do not use inner attribute:

#[pallet]
pub mod pallet {
	//! This inner attribute will make span fail
	..
}

use the newest nightly possible. Macro to define a pallet. Docs are at frame_support::pallet.