1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

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

/// Edit this file to define custom logic or remove it if it is not needed.
/// Learn more about FRAME and the core library of Substrate FRAME pallets:
/// <https://docs.substrate.io/v3/runtime/frame>
pub use pallet::*;

#[cfg(test)]
mod mock;

#[cfg(test)]
mod tests;

#[cfg(feature = "runtime-benchmarks")]
mod benchmarking;

/// All migrations.
pub mod migrations;

#[frame_support::pallet]
pub mod pallet {

  use frame_support::pallet_prelude::*;
  use frame_system::pallet_prelude::*;

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

  /// 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 RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
  }

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

  // The pallet's runtime storage items.
  // https://docs.substrate.io/v3/runtime/storage
  #[pallet::storage]
  #[pallet::getter(fn something)]
  // Learn more about declaring storage items:
  // https://docs.substrate.io/v3/runtime/storage#declaring-storage-items
  pub type Something<T> = StorageValue<_, u32>;

  #[pallet::storage]
  #[pallet::getter(fn my_bytes_val)]
  pub type MyBytesVal<T> = StorageValue<_, MyBytes, ValueQuery>;

  // Pallets use events to inform users when important changes are made.
  // https://docs.substrate.io/v3/runtime/events-and-errors
  #[pallet::event]
  #[pallet::generate_deposit(pub(super) fn deposit_event)]
  pub enum Event<T: Config> {
    /// Event documentation should end with an array that provides descriptive names for event
    /// parameters. [something, who]
    SomethingStored(u32, T::AccountId),
  }

  pub type MyBytes = BoundedVec<u8, ConstU32<16>>;

  // Errors inform users that something went wrong.
  #[pallet::error]
  pub enum Error<T> {
    /// 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.
  #[pallet::call]
  impl<T: Config> Pallet<T> {
    /// 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.
    #[pallet::call_index(0)]
    #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1))]
    pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResult {
      // Check that the extrinsic was signed and get the signer.
      // This function will return an error if the extrinsic is not signed.
      // https://docs.substrate.io/v3/runtime/origins
      let who = ensure_signed(origin)?;

      // Update storage.
      <Something<T>>::put(something);

      // Emit an event.
      Self::deposit_event(Event::SomethingStored(something, who));
      // Return a successful DispatchResultWithPostInfo
      Ok(())
    }

    /// An example dispatchable that may throw a custom error.
    #[pallet::call_index(1)]
    #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
    pub fn cause_error(origin: OriginFor<T>) -> DispatchResult {
      let _who = ensure_signed(origin)?;

      // Read a value from storage.
      match <Something<T>>::get() {
        // Return an error if the value has not been set.
        None => Err(Error::<T>::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::<T>::StorageOverflow)?;
          // Update the value in storage with the incremented result.
          <Something<T>>::put(new);
          Ok(())
        },
      }
    }

    #[pallet::call_index(2)]
    #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1))]
    pub fn insert_my_bytes(
      origin: OriginFor<T>,
      optional_bytes: Option<MyBytes>,
    ) -> DispatchResult {
      // Check that the extrinsic was signed and get the signer.
      // This function will return an error if the extrinsic is not signed.
      // https://docs.substrate.io/v3/runtime/origins
      let _ = ensure_signed(origin)?;

      // Update storage.
      let s = optional_bytes.unwrap_or_default();
      <MyBytesVal<T>>::put(s);
      // Return a successful DispatchResultWithPostInfo
      Ok(())
    }
  }
}