Mesh 2247 - Remove Getters

pallets/asset/src/benchmarking.rs

@@ -20,6 +20,7 @@ use sp_std::collections::btree_set::BTreeSet;
 use sp_std::{convert::TryInto, iter, prelude::*};
 
 use pallet_identity::benchmarking::{user, User, UserBuilder};
+use pallet_portfolio::NextPortfolioNumber;
 use pallet_statistics::benchmarking::setup_transfer_restrictions;
 use polymesh_primitives::agent::AgentGroup;
 use polymesh_primitives::asset::{AssetName, NonFungibleType};
@@ -84,7 +85,7 @@ fn register_metadata_global_name<T: AssetConfig>() -> AssetMetadataKey {
 
     Pallet::<T>::register_asset_metadata_global_type(root, name, spec).unwrap();
 
-    let key = Pallet::<T>::current_asset_metadata_global_key().unwrap();
+    let key = CurrentAssetMetadataGlobalKey::<T>::get().unwrap();
     AssetMetadataKey::Global(key)
 }
 
@@ -198,7 +199,7 @@ pub fn setup_asset_transfer<T: AssetConfig>(
 
 /// Creates a user portfolio for `user`.
 pub fn create_portfolio<T: Config>(user: &User<T>, portofolio_name: &str) -> PortfolioId {
-    let portfolio_number = Portfolio::<T>::next_portfolio_number(user.did()).0;
+    let portfolio_number = NextPortfolioNumber::<T>::get(user.did()).0;
 
     Portfolio::<T>::create_portfolio(
         user.origin().clone().into(),
@@ -435,7 +436,7 @@ benchmarks! {
     verify {
         for i in 1..d {
             assert_eq!(
-                Pallet::<T>::asset_documents(asset_id, DocumentId(i)).unwrap(),
+                AssetDocuments::<T>::get(asset_id, DocumentId(i)).unwrap(),
                 docs[i as usize]
             );
         }
@@ -515,7 +516,7 @@ benchmarks! {
     }: _(bob.origin.clone(), asset_id, 1_000,  PortfolioId::default_portfolio(alice.did()))
     verify {
         assert_eq!(
-            Pallet::<T>::balance_of(asset_id, bob.did()),
+            BalanceOf::<T>::get(asset_id, bob.did()),
             1_000
         );
     }
@@ -525,10 +526,10 @@ benchmarks! {
 
         let alice = UserBuilder::<T>::default().generate_did().build("Alice");
         let ty = vec![b'X'; n as usize];
-        assert_eq!(Pallet::<T>::custom_type_id_seq(), CustomAssetTypeId(0));
+        assert_eq!(CustomTypeIdSequence::<T>::get(), CustomAssetTypeId(0));
     }: _(alice.origin, ty)
     verify {
-        assert_eq!(Pallet::<T>::custom_type_id_seq(), CustomAssetTypeId(1));
+        assert_eq!(CustomTypeIdSequence::<T>::get(), CustomAssetTypeId(1));
     }
 
     set_asset_metadata {

pallets/asset/src/checkpoint/benchmarking.rs

@@ -39,7 +39,7 @@ fn init_with_existing<T: Config>(asset_owner: &User<T>, existing: u64) -> AssetI
 benchmarks! {
     set_schedules_max_complexity {}: _(RawOrigin::Root, 7)
     verify {
-        assert_eq!(Pallet::<T>::schedules_max_complexity(), 7)
+        assert_eq!(SchedulesMaxComplexity::<T>::get(), 7)
     }
 
     create_checkpoint {
@@ -48,14 +48,14 @@ benchmarks! {
         let asset_id = create_sample_asset::<T>(&alice, true);
     }: _(alice.origin, asset_id)
     verify {
-        assert_eq!(Pallet::<T>::checkpoint_id_sequence(asset_id), CheckpointId(1))
+        assert_eq!(CheckpointIdSequence::<T>::get(asset_id), CheckpointId(1))
     }
 
     create_schedule {
         <pallet_timestamp::Now<T>>::set(1000u32.into());
         let alice = UserBuilder::<T>::default().generate_did().build("Alice");
 
-        let max = Pallet::<T>::schedules_max_complexity();
+        let max = SchedulesMaxComplexity::<T>::get();
         let schedule = ScheduleCheckpoints::new_checkpoints(
             (0..max).into_iter().map(|n| CP_BASE + n).collect()
         );
@@ -69,17 +69,17 @@ benchmarks! {
         let asset_id = init_with_existing::<T>(&alice, max);
     }: _(alice.origin, asset_id, schedule)
     verify {
-        assert_eq!(Pallet::<T>::schedule_id_sequence(asset_id), ScheduleId(max + 1))
+        assert_eq!(ScheduleIdSequence::<T>::get(asset_id), ScheduleId(max + 1))
     }
 
     remove_schedule {
         let alice = UserBuilder::<T>::default().generate_did().build("Alice");
-        let max = Pallet::<T>::schedules_max_complexity();
+        let max = SchedulesMaxComplexity::<T>::get();
 
         let id = ScheduleId(max);
         let asset_id = init_with_existing::<T>(&alice, max);
     }: _(alice.origin, asset_id, id)
     verify {
-        assert_eq!(Pallet::<T>::scheduled_checkpoints(asset_id, id), None);
+        assert_eq!(ScheduledCheckpoints::<T>::get(asset_id, id), None);
     }
 }

pallets/asset/src/checkpoint/mod.rs

@@ -124,8 +124,7 @@ pub mod pallet {
     ///
     /// ([`AssetId`], checkpointId) -> total supply at given checkpoint
     #[pallet::storage]
-    #[pallet::getter(fn total_supply_at)]
-    pub(super) type TotalSupply<T: Config> = StorageDoubleMap<
+    pub type TotalSupply<T: Config> = StorageDoubleMap<
         _,
         Blake2_128Concat,
         AssetId,
@@ -139,8 +138,7 @@ pub mod pallet {
     ///
     /// ([`AssetId`], did, checkpoint ID) -> Balance of a DID at a checkpoint
     #[pallet::storage]
-    #[pallet::getter(fn balance_at_checkpoint)]
-    pub(super) type Balance<T: Config> = StorageDoubleMap<
+    pub type Balance<T: Config> = StorageDoubleMap<
         _,
         Blake2_128Concat,
         (AssetId, CheckpointId),
@@ -157,16 +155,14 @@ pub mod pallet {
     ///
     /// ([`AssetId`]) -> no. of checkpoints
     #[pallet::storage]
-    #[pallet::getter(fn checkpoint_id_sequence)]
-    pub(super) type CheckpointIdSequence<T: Config> =
+    pub type CheckpointIdSequence<T: Config> =
         StorageMap<_, Blake2_128Concat, AssetId, CheckpointId, ValueQuery>;
 
     /// Checkpoints where a DID's balance was updated.
     /// ([`AssetId`], did) -> [checkpoint ID where user balance changed]
     #[pallet::storage]
     #[pallet::unbounded]
-    #[pallet::getter(fn balance_updates)]
-    pub(super) type BalanceUpdates<T: Config> = StorageDoubleMap<
+    pub type BalanceUpdates<T: Config> = StorageDoubleMap<
         _,
         Blake2_128Concat,
         AssetId,
@@ -183,8 +179,7 @@ pub mod pallet {
     ///
     /// ([`AssetId`]) -> (checkpoint ID) -> checkpoint timestamp
     #[pallet::storage]
-    #[pallet::getter(fn timestamps)]
-    pub(super) type Timestamps<T: Config> = StorageDoubleMap<
+    pub type Timestamps<T: Config> = StorageDoubleMap<
         _,
         Blake2_128Concat,
         AssetId,
@@ -198,15 +193,13 @@ pub mod pallet {
 
     /// The maximum complexity allowed for an asset's schedules.
     #[pallet::storage]
-    #[pallet::getter(fn schedules_max_complexity)]
-    pub(super) type SchedulesMaxComplexity<T: Config> = StorageValue<_, u64, ValueQuery>;
+    pub type SchedulesMaxComplexity<T: Config> = StorageValue<_, u64, ValueQuery>;
 
     /// Checkpoint schedule ID sequence for assets.
     ///
     /// ([`AssetId`]) -> schedule ID
     #[pallet::storage]
-    #[pallet::getter(fn schedule_id_sequence)]
-    pub(super) type ScheduleIdSequence<T: Config> =
+    pub type ScheduleIdSequence<T: Config> =
         StorageMap<_, Blake2_128Concat, AssetId, ScheduleId, ValueQuery>;
 
     /// Cached next checkpoint for each schedule.
@@ -216,17 +209,15 @@ pub mod pallet {
     /// ([`AssetId`]) -> next checkpoints
     #[pallet::storage]
     #[pallet::unbounded]
-    #[pallet::getter(fn cached_next_checkpoints)]
-    pub(super) type CachedNextCheckpoints<T: Config> =
+    pub type CachedNextCheckpoints<T: Config> =
         StorageMap<_, Blake2_128Concat, AssetId, NextCheckpoints, OptionQuery>;
 
     /// Scheduled checkpoints.
     ///
     /// ([`AssetId`], schedule ID) -> schedule checkpoints
     #[pallet::storage]
     #[pallet::unbounded]
-    #[pallet::getter(fn scheduled_checkpoints)]
-    pub(super) type ScheduledCheckpoints<T: Config> = StorageDoubleMap<
+    pub type ScheduledCheckpoints<T: Config> = StorageDoubleMap<
         _,
         Blake2_128Concat,
         AssetId,
@@ -245,17 +236,15 @@ pub mod pallet {
     ///
     /// ([`AssetId`], schedule ID) -> strong ref count
     #[pallet::storage]
-    #[pallet::getter(fn schedule_ref_count)]
-    pub(super) type ScheduleRefCount<T: Config> =
+    pub type ScheduleRefCount<T: Config> =
         StorageDoubleMap<_, Blake2_128Concat, AssetId, Twox64Concat, ScheduleId, u32, ValueQuery>;
 
     /// All the checkpoints a given schedule originated.
     ///
     /// ([`AssetId`], schedule ID) -> [checkpoint ID]
     #[pallet::storage]
     #[pallet::unbounded]
-    #[pallet::getter(fn schedule_points)]
-    pub(super) type SchedulePoints<T: Config> = StorageDoubleMap<
+    pub type SchedulePoints<T: Config> = StorageDoubleMap<
         _,
         Blake2_128Concat,
         AssetId,
@@ -267,7 +256,6 @@ pub mod pallet {
 
     /// Storage version.
     #[pallet::storage]
-    #[pallet::getter(fn storage_version)]
     pub(super) type StorageVersion<T: Config> = StorageValue<_, Version, ValueQuery>;
 
     #[pallet::genesis_config]
@@ -429,7 +417,7 @@ impl<T: AssetConfig> Pallet<T> {
                 // Use first checkpoint created after target checkpoint.
                 // The user has data for that checkpoint.
                 let id = *find_ceiling(&balance_updates, &cp);
-                return Some(Self::balance_at_checkpoint((asset_id, id), did));
+                return Some(Balance::<T>::get((asset_id, id), did));
             }
             // User has not transacted after checkpoint creation.
             // This means their current balance = their balance at that cp.