When should I use #[pallet::generate_store(pub(super) trait Store)]

Question

I'm fiddling with substrate's #[pallet::generate_store(pub(super) trait Store)]
https://docs.substrate.io/v3/runtime/macros/#palletpallet

Documentation says

Generates the Store trait if the attribute is provided, which contains an associated type for each storage item. It takes the form of a more explicit Rust struct module and can be written as pub struct Pallet(_);, with the appropriate PhantomData replacing _ to make it generic.

Here is my kittens pallet. Even if I remove the macro mentioned above, node works fine as expected.
https://github.com/yourarj/substrate-node-playground/blob/adfafc5e0733ade8fd9b422585716baea11da35a/pallets/kittens/src/lib.rs#L13

I tried applying cargo expand with both cases is that I found out the following differences. A Store trait and it's implemented for Pallet Struct.

But in both the cases my functionality is not impacted at all. It mutates chain state and queries the state as expected.

So

Why should we use this #[pallet::generate_store(pub(super) trait Store)]? What's the point?

Answer 1

I believe this is an artifact from the the old design for how we collected all the different storage items in the decl_storage! macro in FRAME v1.

Here is an example definition:

crate::decl_storage! {
    trait Store for Module<T: Config> as Runtime {
        Value get(fn value) config(): (u64, u64);
        NumberMap: map hasher(identity) u32 => u64;
        DoubleMap: double_map hasher(identity) u32, hasher(identity) u32 => u64;
    }
}

As you can see, the old macro simply wrapped an entire trait Store, and generated all the storage items using this.

When redesigning FRAME storage for FRAME v2, an individual type pattern was used:

#[pallet::storage]
pub type Value<T> = StorageValue<_, u32>;

#[pallet::storage]
pub type Map<T> = StorageMap<_, Blake2_128Concat, u8, u16>;

#[pallet::storage]
pub type DoubleMap<T> =
    StorageDoubleMap<_, Blake2_128Concat, u8, Twox64Concat, u16, u32>;

To maintain backwards compatibility, this extra generate_store attribute was created. It should not affect you as a pallet developer if you use it or not.

Answer 2

The Store trait, as you see, just creates some aliases, and is completely optional.

For example, with this trait, you can access all of the storage items regardless of being pub or not as associated type Pallet. Although, in FRAME v2 all storage items have to be pub(crate) at the minimum, and I think the Store trait only exists in FRAME v2 for backwards compatibility and will likely be removed in further versions.

Answer 3

I tried to declare storage as private as below

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

#[pallet::storage]
#[pallet::getter( fn running_status)]
type SystemRunnig<T> = StorageValue<_, bool, ValueQuery>;

It compiles fine and even I am able to access and see the status of the SystemRunnig from polkadotJs explorer.

So here what is meant via declaring it private. can you explain