diff --git a/bin/node-template/pallets/template/src/lib.rs b/bin/node-template/pallets/template/src/lib.rs index 7fdf75bb25b14..5bf76624c1f18 100644 --- a/bin/node-template/pallets/template/src/lib.rs +++ b/bin/node-template/pallets/template/src/lib.rs @@ -4,8 +4,7 @@ /// Learn more about FRAME and the core library of Substrate FRAME pallets: /// https://substrate.dev/docs/en/knowledgebase/runtime/frame -use frame_support::{decl_module, decl_storage, decl_event, decl_error, dispatch, traits::Get}; -use frame_system::ensure_signed; +pub use pallet::*; #[cfg(test)] mod mock; @@ -13,89 +12,91 @@ mod mock; #[cfg(test)] mod tests; -/// Configure the pallet by specifying the parameters and types on which it depends. -pub trait Config: frame_system::Config { - /// Because this pallet emits events, it depends on the runtime's definition of an event. - type Event: From> + Into<::Event>; -} +#[frame_support::pallet] +pub mod pallet { + use frame_support::{dispatch::DispatchResultWithPostInfo, pallet_prelude::*}; + use frame_system::pallet_prelude::*; -// The pallet's runtime storage items. -// https://substrate.dev/docs/en/knowledgebase/runtime/storage -decl_storage! { - // A unique name is used to ensure that the pallet's storage items are isolated. - // This name may be updated, but each pallet in the runtime must use a unique name. - // ---------------------------------vvvvvvvvvvvvvv - trait Store for Module as TemplateModule { - // Learn more about declaring storage items: - // https://substrate.dev/docs/en/knowledgebase/runtime/storage#declaring-storage-items - Something get(fn something): Option; + /// Configure the pallet by specifying the parameters and types on which it depends. + #[pallet::config] + pub trait Config: frame_system::Config { + /// Because this pallet emits events, it depends on the runtime's definition of an event. + type Event: From> + IsType<::Event>; } -} -// Pallets use events to inform users when important changes are made. -// https://substrate.dev/docs/en/knowledgebase/runtime/events -decl_event! { - pub enum Event where AccountId = ::AccountId { + #[pallet::pallet] + #[pallet::generate_store(pub(super) trait Store)] + pub struct Pallet(PhantomData); + + // The pallet's runtime storage items. + // https://substrate.dev/docs/en/knowledgebase/runtime/storage + #[pallet::storage] + #[pallet::getter(fn something)] + // Learn more about declaring storage items: + // https://substrate.dev/docs/en/knowledgebase/runtime/storage#declaring-storage-items + pub type Something = StorageValue<_, u32>; + + // Pallets use events to inform users when important changes are made. + // https://substrate.dev/docs/en/knowledgebase/runtime/events + #[pallet::event] + #[pallet::metadata(T::AccountId = "AccountId")] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { /// Event documentation should end with an array that provides descriptive names for event /// parameters. [something, who] - SomethingStored(u32, AccountId), + SomethingStored(u32, T::AccountId), } -} - -// Errors inform users that something went wrong. -decl_error! { - pub enum Error for Module { + + // Errors inform users that something went wrong. + #[pallet::error] + pub enum Error { /// Error names should be descriptive. NoneValue, /// Errors should have helpful documentation associated with them. StorageOverflow, } -} - -// Dispatchable functions allows users to interact with the pallet and invoke state changes. -// These functions materialize as "extrinsics", which are often compared to transactions. -// Dispatchable functions must be annotated with a weight and must return a DispatchResult. -decl_module! { - pub struct Module for enum Call where origin: T::Origin { - // Errors must be initialized if they are used by the pallet. - type Error = Error; - // Events must be initialized if they are used by the pallet. - fn deposit_event() = default; + #[pallet::hooks] + impl Hooks> for Pallet {} + // Dispatchable functions allows users to interact with the pallet and invoke state changes. + // These functions materialize as "extrinsics", which are often compared to transactions. + // Dispatchable functions must be annotated with a weight and must return a DispatchResult. + #[pallet::call] + impl Pallet { /// An example dispatchable that takes a singles value as a parameter, writes the value to /// storage and emits an event. This function must be dispatched by a signed extrinsic. - #[weight = 10_000 + T::DbWeight::get().writes(1)] - pub fn do_something(origin, something: u32) -> dispatch::DispatchResult { + #[pallet::weight(10_000 + T::DbWeight::get().writes(1))] + pub fn do_something(origin: OriginFor, something: u32) -> DispatchResultWithPostInfo { // Check that the extrinsic was signed and get the signer. // This function will return an error if the extrinsic is not signed. // https://substrate.dev/docs/en/knowledgebase/runtime/origin let who = ensure_signed(origin)?; // Update storage. - Something::put(something); + >::put(something); // Emit an event. - Self::deposit_event(RawEvent::SomethingStored(something, who)); - // Return a successful DispatchResult - Ok(()) + Self::deposit_event(Event::SomethingStored(something, who)); + // Return a successful DispatchResultWithPostInfo + Ok(().into()) } /// An example dispatchable that may throw a custom error. - #[weight = 10_000 + T::DbWeight::get().reads_writes(1,1)] - pub fn cause_error(origin) -> dispatch::DispatchResult { + #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1))] + pub fn cause_error(origin: OriginFor) -> DispatchResultWithPostInfo { let _who = ensure_signed(origin)?; // Read a value from storage. - match Something::get() { + match >::get() { // Return an error if the value has not been set. None => Err(Error::::NoneValue)?, Some(old) => { // Increment the value read from storage; will error in the event of overflow. let new = old.checked_add(1).ok_or(Error::::StorageOverflow)?; // Update the value in storage with the incremented result. - Something::put(new); - Ok(()) + >::put(new); + Ok(().into()) }, } }