Macro frame_support::decl_module[][src]

macro_rules! decl_module {
    ($(#[$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
 $(, $where_ty : ty : $where_bound : path) * $(,) ? { $($t : tt) * }) => { ... };
    ($(#[$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 $(, $where_ty : ty : $where_bound : path) * $(,) ?
 { $($t : tt) * }) => { ... };
    (@ 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) * } { }
 { $($on_initialize : tt) * } { $($on_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * $vis : vis fn
 deposit_event() = default ; $($rest : tt) *) => { ... };
    (@ 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) * } { }
 { $($on_initialize : tt) * } { $($on_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * $vis : vis fn
 deposit_event $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * $vis : vis fn deposit_event() = default ;
 $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * } { }
 { $($offchain : tt) * } { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn
 on_finalize($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * } { }
 { $($offchain : tt) * } { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) *
 #[weight = $weight : expr] fn
 on_finalize($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) + } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * #[weight = $weight : expr] fn
 on_finalize($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { } { $($on_finalize : tt) * }
 { $($offchain : tt) * } { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn
 on_idle($param_name1 : ident : $param1 : ty, $param_name2 : ident : $param2 :
         ty $(,) ?) -> $return : ty { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_finalize : tt) * }
 { $($offchain : tt) * } { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) *
 $(#[weight = $weight : expr]) ? fn on_idle $($rest : tt) *) => { ... };
    (@ 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_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn
 on_runtime_upgrade($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) *
 #[weight = $weight : expr] fn
 on_runtime_upgrade($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn
 on_runtime_upgrade($($param_name : ident : $param : ty), * $(,) ?) -> $return
 : ty { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) + } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * fn
 on_runtime_upgrade($($param_name : ident : $param : ty), * $(,) ?) -> $return
 : ty { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn integrity_test()
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) + }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * fn integrity_test() { $($impl : tt) * }
 $($rest : tt) *) => { ... };
    (@ 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_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn
 on_initialize($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) *
 #[weight = $weight : expr] fn
 on_initialize($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * fn
 on_initialize($($param_name : ident : $param : ty), * $(,) ?) -> $return : ty
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * fn
 on_initialize($($param_name : ident : $param : ty), * $(,) ?) -> $return : ty
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * fn
 offchain_worker($($param_name : ident : $param : ty), * $(,) ?)
 { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) + } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * fn
 offchain_worker($($param_name : ident : $param : ty), * $(,) ?) -> $return :
 ty { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * const $name : ident :
 $ty : ty = $value : expr ; $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * type Error = $error_type : ty ; $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($t : tt) *] $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * type StorageVersion = $storage_version : path ;
 $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) *
 #[weight = $weight : expr] $(#[$fn_attr : meta]) * $fn_vis : vis fn $fn_name
 :
 ident($origin : ident
       $(, $(#[$codec_attr : ident]) * $param_name : ident : $param : ty) *
       $(,) ?) $(-> $result : ty) * { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) * $(#[$fn_attr : meta])
 * $fn_vis : vis fn $fn_name :
 ident($from : ident
       $(, $(#[$codec_attr : ident]) * $param_name : ident : $param : ty) *
       $(,) ?) $(-> $result : ty) * { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * $(#[weight = $weight : expr]) ?
 $(#[$fn_attr : meta]) * $fn_vis : vis fn $fn_name :
 ident($origin : ident : T :: Origin
       $(, $(#[$codec_attr : ident]) * $param_name : ident : $param : ty) *
       $(,) ?) $(-> $result : ty) * { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]
 $(#[doc = $doc_attr : tt]) * $(#[weight = $weight : expr]) ?
 $(#[$fn_attr : meta]) * $fn_vis : vis fn $fn_name :
 ident(origin : $origin : ty
       $(, $(#[$codec_attr : ident]) * $param_name : ident : $param : ty) *
       $(,) ?) $(-> $result : ty) * { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ normalize $(#[$attr : meta]) * pub struct $mod_type : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $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_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }
 [$($dispatchables : tt) *] $(#[doc = $doc_attr : tt]) *
 $(#[weight = $weight : expr]) ? $(#[$fn_attr : meta]) * $fn_vis : vis fn
 $fn_name :
 ident($($(#[$codec_attr : ident]) * $param_name : ident : $param : ty), *
       $(,) ?) $(-> $result : ty) * { $($impl : tt) * } $($rest : tt) *) => { ... };
    (@ 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_runtime_upgrade : tt) * } { $($on_idle : tt) * }
 { $($on_finalize : tt) * } { $($offchain : tt) * } { $($constants : tt) * }
 { $($error_type : tt) * } { $($integrity_test : tt) * }
 { $($storage_version : tt) * } [$($dispatchables : tt) *]) => { ... };
    (@ call $ignore : ident $mod_type : ident < $trait_instance : ident
 $(, $instance : ident) ? > $fn_name : ident $origin : ident $system : ident
 [$($param_name : ident), *]) => { ... };
    (@ impl_deposit_event $module : ident < $trait_instance : ident : $trait_name
 : ident $(< I >, I : $instantiable : path) ? > ; $system : ident ;
 { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_deposit_event $module : ident < $trait_instance : ident : $trait_name
 : ident $(< I >, $instance : ident : $instantiable : path) ? > ; $system :
 ident ; { $($other_where_bounds : tt) * } $vis : vis fn deposit_event
 $(< $event_trait_instance : ident $(, $event_instance : ident) ? >) ? () =
 default ;) => { ... };
    (@ impl_on_initialize { $system : ident } $module : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } fn on_initialize() -> $return : ty
 { $($impl : tt) * }) => { ... };
    (@ impl_on_initialize { $system : ident } $module : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } fn
 on_initialize($param : ident : $param_ty : ty) -> $return : ty
 { $($impl : tt) * }) => { ... };
    (@ impl_on_initialize { $system : ident } $module : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_on_runtime_upgrade { $system : ident } $module : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } fn on_runtime_upgrade() -> $return : ty
 { $($impl : tt) * }) => { ... };
    (@ impl_on_runtime_upgrade { $system : ident } $module : ident <
 $trait_instance : ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_integrity_test $module : ident < $trait_instance : ident : $trait_name
 : ident $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } $(#[doc = $doc_attr : tt]) * fn
 integrity_test() { $($impl : tt) * }) => { ... };
    (@ impl_integrity_test $module : ident < $trait_instance : ident : $trait_name
 : ident $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_on_finalize { $system : ident } $module : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } fn on_finalize() { $($impl : tt) * }) => { ... };
    (@ impl_on_finalize { $system : ident } $module : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } fn
 on_finalize($param : ident : $param_ty : ty) { $($impl : tt) * }) => { ... };
    (@ impl_on_finalize { $system : ident } $module : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_on_idle { $system : ident } $module : ident < $trait_instance : ident
 : $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? >
 ; { $($other_where_bounds : tt) * } fn
 on_idle($param1 : ident : $param1_ty : ty, $param2 : ident : $param2_ty : ty)
 -> $return : ty { $($impl : tt) * }) => { ... };
    (@ impl_on_idle { $system : ident } $module : ident < $trait_instance : ident
 : $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? >
 ; { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_offchain { $system : ident } $module : ident < $trait_instance : ident
 : $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? >
 ; { $($other_where_bounds : tt) * } fn offchain_worker() { $($impl : tt) * }) => { ... };
    (@ impl_offchain { $system : ident } $module : ident < $trait_instance : ident
 : $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? >
 ; { $($other_where_bounds : tt) * } fn
 offchain_worker($param : ident : $param_ty : ty) { $($impl : tt) * }) => { ... };
    (@ impl_offchain { $system : ident } $module : ident < $trait_instance : ident
 : $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? >
 ; { $($other_where_bounds : tt) * }) => { ... };
    (@ impl_function $module : ident < $trait_instance : ident : $trait_name :
 ident $(< I >, $instance : ident : $instantiable : path) ? > ; $origin_ty :
 ty ; $ignore : ident ; $(#[$fn_attr : meta]) * $vis : vis fn $name :
 ident($origin : ident $(, $param : ident : $param_ty : ty) *)
 { $($impl : tt) * }) => { ... };
    (@ impl_function $module : ident < $trait_instance : ident : $trait_name :
 ident $(< I >, $instance : ident : $instantiable : path) ? > ; $origin_ty :
 ty ; $ignore : ident ; $(#[$fn_attr : meta]) * $vis : vis fn $name :
 ident($origin : ident $(, $param : ident : $param_ty : ty) *) -> $result : ty
 { $($impl : tt) * }) => { ... };
    (@ create_call_enum $call_type : ident ; < $trait_instance : ident :
 $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path
   $(= $module_default_instance : path) ?) ? >
 { $($other_where_bounds : tt) * } { $($generated_variants : tt) * }
 { $($current_params : tt) * } variant $fn_name : ident ;
 $(#[doc = $doc_attr : tt]) * #[compact] $name : ident : $type : ty ;
 $($rest : tt) *) => { ... };
    (@ create_call_enum $call_type : ident ; < $trait_instance : ident :
 $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path
   $(= $module_default_instance : path) ?) ? >
 { $($other_where_bounds : tt) * } { $($generated_variants : tt) * }
 { $($current_params : tt) * } variant $fn_name : ident ;
 $(#[doc = $doc_attr : tt]) * $name : ident : $type : ty ; $($rest : tt) *) => { ... };
    (@ create_call_enum $call_type : ident ; < $trait_instance : ident :
 $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path
   $(= $module_default_instance : path) ?) ? >
 { $($other_where_bounds : tt) * } { $($generated_variants : tt) * }
 { $($current_params : tt) * } variant $fn_name : ident ;
 $(#[doc = $doc_attr : tt]) *
 $(variant $next_fn_name : ident ; $($rest : tt) *) ?) => { ... };
    (@ create_call_enum $call_type : ident ; < $trait_instance : ident :
 $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path
   $(= $module_default_instance : path) ?) ? >
 { $($other_where_bounds : tt) * } { $($generated_variants : tt) * } { }) => { ... };
    (@ impl_get_storage_version $module : ident < $trait_instance : ident :
 $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * } $($storage_version : tt) +) => { ... };
    (@ impl_get_storage_version $module : ident < $trait_instance : ident :
 $trait_name : ident $(< I >, $instance : ident : $instantiable : path) ? > ;
 { $($other_where_bounds : tt) * }) => { ... };
    (@ imp $(#[$attr : meta]) * pub struct $mod_type : ident < $trait_instance :
 ident : $trait_name : ident
 $(< I >, $instance : ident : $instantiable : path
   $(= $module_default_instance : path) ?) ? > for enum $call_type : ident
 where origin : $origin_type : ty, system = $system : ident
 {
     $($(#[doc = $doc_attr : tt]) * #[weight = $weight : expr]
       $(#[$fn_attr : meta]) * $fn_vis : vis fn $fn_name :
       ident($from : ident
             $(, $(#[$codec_attr : ident]) * $param_name : ident : $param :
               ty) *) $(-> $result : ty) * { $($impl : tt) * }
       { $($fn_instance : ident : $fn_instantiable : path) ? }) *
 } { $($other_where_bounds : tt) * } { $($deposit_event : tt) * }
 { $($on_initialize : tt) * } { $($on_runtime_upgrade : tt) * }
 { $($on_idle : tt) * } { $($on_finalize : tt) * } { $($offchain : tt) * }
 { $($constants : tt) * } { $($error_type : tt) * }
 { $($integrity_test : tt) * } { $($storage_version : tt) * }) => { ... };
}
Expand description

Declares a Module struct and a Call enum, which implements the dispatch logic.

Declaration

decl_module! {
	pub struct Module<T: Config> for enum Call where origin: T::Origin {

		// Private functions are dispatchable, but not available to other
		// FRAME pallets.
		#[weight = 0]
		fn my_function(origin, var: u64) -> dispatch::DispatchResult {
				// Your implementation
				Ok(())
		}

			// Public functions are both dispatchable and available to other
		// FRAME pallets.
		#[weight = 0]
			pub fn my_public_function(origin) -> dispatch::DispatchResult {
			// Your implementation
				Ok(())
		}
		}
}

The declaration is set with the header where:

  • Module: The struct generated by the macro, with type Config.
  • Call: The enum generated for every pallet, which implements Callable.
  • origin: Alias of T::Origin.
  • Result: The expected return type from pallet functions.

The first parameter of dispatchable functions must always be origin.

Shorthand Example

The macro automatically expands a shorthand function declaration to return the DispatchResult type. These functions are the same:

decl_module! {
	pub struct Module<T: Config> for enum Call where origin: T::Origin {
		#[weight = 0]
		fn my_long_function(origin) -> dispatch::DispatchResult {
				// Your implementation
			Ok(())
		}

		#[weight = 0]
		fn my_short_function(origin) {
				// Your implementation
		}
		}
}

Consuming only portions of the annotated static weight

Per default a callable function consumes all of its static weight as declared via the #[weight] attribute. However, there are use cases where only a portion of this weight should be consumed. In that case the static weight is charged pre dispatch and the difference is refunded post dispatch.

In order to make use of this feature the function must return DispatchResultWithPostInfo in place of the default DispatchResult. Then the actually consumed weight can be returned. To consume a non default weight while returning an error WithPostDispatchInfo::with_weight can be used to augment any error with custom weight information.

decl_module! {
	pub struct Module<T: Config> for enum Call where origin: T::Origin {
		#[weight = 1_000_000]
		fn my_long_function(origin, do_expensive_calc: bool) -> DispatchResultWithPostInfo {
			ensure_signed(origin).map_err(|e| e.with_weight(100_000))?;
			if do_expensive_calc {
				// do the expensive calculation
				// ...
				// return None to indicate that we are using all weight (the default)
				return Ok(None.into());
			}
			// expensive calculation not executed: use only a portion of the weight
			Ok(Some(100_000).into())
		}
	}
}

Transactional Function Example

Transactional function discards all changes to storage if it returns Err, or commits if Ok, via the #[transactional] attribute. Note the attribute must be after #[weight].

decl_module! {
	pub struct Module<T: Config> for enum Call where origin: T::Origin {
		#[weight = 0]
		#[transactional]
		fn my_short_function(origin) {
				// Your implementation
		}
	}
}

Privileged Function Example

A privileged function checks that the origin of the call is ROOT.

decl_module! {
	pub struct Module<T: Config> for enum Call where origin: T::Origin {
		#[weight = 0]
			fn my_privileged_function(origin) -> dispatch::DispatchResult {
			ensure_root(origin)?;
				// Your implementation
			Ok(())
		}
		}
}

Attributes on Functions

Attributes on functions are supported, but must be in the order of:

  1. Optional #[doc] attribute.
  2. #[weight] attribute.
  3. Optional function attributes, for instance #[transactional]. Those function attributes will be written only on the dispatchable functions implemented on Module, not on the Call enum variant.

Multiple Module Instances Example

A Substrate module can be built such that multiple instances of the same module can be used within a single runtime. For example, the Balances module can be added multiple times to your runtime in order to support multiple, independent currencies for your blockchain. Here is an example of how you would declare such a module using the decl_module! macro:

pub trait Config<I: Instance=DefaultInstance>: frame_system::Config {}

decl_module! {
	pub struct Module<T: Config<I>, I: Instance = DefaultInstance> for enum Call where origin: T::Origin {
		// Your implementation
	}
}

Note: decl_storage must be called to generate Instance trait and optionally DefaultInstance type.

Where clause

Besides the default origin: T::Origin, you can also pass other bounds to the module declaration. This where bound will be replicated to all types generated by this macro. The chaining of multiple trait bounds with + is not supported. If multiple bounds for one type are required, it needs to be split up into multiple bounds.

pub trait Config: system::Config where Self::AccountId: From<u32> {}

decl_module! {
	pub struct Module<T: Config> for enum Call where origin: T::Origin, T::AccountId: From<u32> {
		// Your implementation
	}
}

Reserved Functions

The following are reserved function signatures:

  • deposit_event: Helper function for depositing an event. The default behavior is to call deposit_event from the System module. However, you can write your own implementation for events in your runtime. To use the default behavior, add fn deposit_event() = default; to your Module.

The following reserved functions also take the block number (with type T::BlockNumber) as an optional input:

  • on_runtime_upgrade: Executes at the beginning of a block prior to on_initialize when there 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 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 trait. Function signature can be either:

    • fn on_initialize(n: BlockNumber) -> frame_support::weights::Weight or
    • fn on_initialize() -> frame_support::weights::Weight
  • on_idle: Executes at the end of a block. Passes a remaining weight to provide a threshold for when to execute non vital functions. Using this function will implement the OnIdle trait. Function signature is:

    • fn on_idle(n: BlockNumber, remaining_weight: Weight) -> frame_support::weights::Weight
  • on_finalize: Executes at the end of a block. Using this function will implement the OnFinalize 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 trait.

  • integrity_test: Executes in a test generated by construct_runtime, note it doesn’t execute in an externalities-provided environment. Implement IntegrityTest trait.