Sys 4010 make autogrowth mechanism configurable

node/src/chain_spec/stable/mod.rs

@@ -120,6 +120,7 @@ pub(crate) fn testnet_genesis(
             min_collator_stake: COLLATOR_DEPOSIT,
             min_total_nominator_stake: 10 * AVT,
             delay: 2,
+            growth_enabled: true,
         },
         polkadot_xcm: avn_runtime::PolkadotXcmConfig {
             safe_xcm_version: Some(SAFE_XCM_VERSION),

pallets/parachain-staking/src/lib.rs

@@ -245,6 +245,8 @@ pub mod pallet {
         type AccountToBytesConvert: pallet_avn::AccountToBytesConverter<Self::AccountId>;
 
         type BridgeInterface: pallet_avn::BridgeInterface;
+
+        type GrowthEnabled: Get<bool>;
     }
 
     #[pallet::error]
@@ -489,6 +491,10 @@ pub mod pallet {
         }
     }
 
+    #[pallet::storage]
+    #[pallet::getter(fn growth_enabled)]
+    pub type GrowthEnabled<T> = StorageValue<_, bool, ValueQuery>;
+
     #[pallet::storage]
     #[pallet::getter(fn delay)]
     /// Number of eras to wait before executing any staking action
@@ -687,6 +693,7 @@ pub mod pallet {
         pub delay: EraIndex,
         pub min_collator_stake: BalanceOf<T>,
         pub min_total_nominator_stake: BalanceOf<T>,
+        pub growth_enabled: bool,
     }
 
     impl<T: Config> Default for GenesisConfig<T> {
@@ -697,6 +704,7 @@ pub mod pallet {
                 delay: Default::default(),
                 min_collator_stake: Default::default(),
                 min_total_nominator_stake: Default::default(),
+                growth_enabled: T::GrowthEnabled::get(),
             }
         }
     }
@@ -760,6 +768,8 @@ pub mod pallet {
             assert!(self.delay > 0, "Delay must be greater than 0.");
             <Delay<T>>::put(self.delay);
 
+            GrowthEnabled::<T>::put(self.growth_enabled);
+
             // Set min staking values
             <MinCollatorStake<T>>::put(self.min_collator_stake);
             <MinTotalNominatorStake<T>>::put(self.min_total_nominator_stake);
@@ -1675,6 +1685,7 @@ pub mod pallet {
                 AdminSettings::Delay(d) => <Delay<T>>::put(d),
                 AdminSettings::MinCollatorStake(s) => <MinCollatorStake<T>>::put(s),
                 AdminSettings::MinTotalNominatorStake(s) => <MinTotalNominatorStake<T>>::put(s),
+                AdminSettings::GrowthEnabled(b) => <GrowthEnabled<T>>::put(b),
             }
 
             Self::deposit_event(Event::AdminSettingsUpdated { value });
@@ -1831,18 +1842,21 @@ pub mod pallet {
 
             <DelayedPayouts<T>>::insert(era_to_payout, &payout);
 
-            let collator_scores_vec: Vec<CollatorScore<T::AccountId>> =
-                <AwardedPts<T>>::iter_prefix(era_to_payout)
-                    .map(|(collator, points)| CollatorScore::new(collator, points))
-                    .collect::<Vec<CollatorScore<T::AccountId>>>();
-            let collator_scores = BoundedVec::truncate_from(collator_scores_vec);
-            Self::update_collator_payout(
-                era_to_payout,
-                total_staked,
-                payout,
-                total_points,
-                collator_scores,
-            );
+            let growth_enabled = GrowthEnabled::<T>::get();
+            if growth_enabled {
+                let collator_scores_vec: Vec<CollatorScore<T::AccountId>> =
+                    <AwardedPts<T>>::iter_prefix(era_to_payout)
+                        .map(|(collator, points)| CollatorScore::new(collator, points))
+                        .collect::<Vec<CollatorScore<T::AccountId>>>();
+                let collator_scores = BoundedVec::truncate_from(collator_scores_vec);
+                Self::update_collator_payout(
+                    era_to_payout,
+                    total_staked,
+                    payout,
+                    total_points,
+                    collator_scores,
+                );
+            }
         }
 
         /// Wrapper around pay_one_collator_reward which handles the following logic:

pallets/parachain-staking/src/tests/mock.rs

@@ -203,6 +203,7 @@ parameter_types! {
     pub const ErasPerGrowthPeriod: u32 = 2;
     pub const RewardPotId: PalletId = PalletId(*b"av/vamgr");
     pub const MaxCandidates:u32 = 100;
+    pub const GrowthEnabled: bool = true;
 }
 
 pub struct IsRegistered;
@@ -242,6 +243,7 @@ impl Config for Test {
     type MaxCandidates = MaxCandidates;
     type AccountToBytesConvert = AVN;
     type BridgeInterface = EthBridge;
+    type GrowthEnabled = GrowthEnabled;
 }
 
 // Deal with any positive imbalance by sending it to the fake treasury
@@ -566,6 +568,7 @@ impl ExtBuilder {
             delay: 2,
             min_collator_stake: self.min_collator_stake,
             min_total_nominator_stake: self.min_total_nominator_stake,
+            growth_enabled: true,
         }
         .assimilate_storage(&mut t)
         .expect("Parachain Staking's storage can be assimilated");

pallets/parachain-staking/src/tests/test_admin_settings.rs

@@ -4,8 +4,8 @@ use crate::mock::{
     RuntimeOrigin as Origin, Test, TestAccount,
 };
 use crate::{
-    assert_last_event, AdminSettings, BalanceOf, Delay, Error, Event, MinCollatorStake,
-    MinTotalNominatorStake,
+    assert_last_event, AdminSettings, BalanceOf, Delay, Error, Event, GrowthEnabled,
+    MinCollatorStake, MinTotalNominatorStake,
 };
 use frame_support::{assert_noop, assert_ok};
 use frame_system::RawOrigin;
@@ -154,3 +154,45 @@ mod min_collator_stake_admin_setting {
         });
     }
 }
+
+mod growth_enabled_admin_setting {
+    use super::*;
+
+    #[test]
+    fn can_be_updated() {
+        ExtBuilder::default().build().execute_with(|| {
+            let initial_value = <GrowthEnabled<Test>>::get();
+            let new_growth_enabled_setting =
+                AdminSettings::<BalanceOf<Test>>::GrowthEnabled(!initial_value);
+
+            assert_ok!(ParachainStaking::set_admin_setting(
+                Origin::root(),
+                new_growth_enabled_setting.clone()
+            ));
+
+            assert_eq!(<GrowthEnabled<Test>>::get(), !initial_value);
+            assert_last_event!(MetaEvent::ParachainStaking(Event::AdminSettingsUpdated {
+                value: new_growth_enabled_setting
+            }));
+        });
+    }
+
+    #[test]
+    fn can_be_updated_to_same_value() {
+        ExtBuilder::default().build().execute_with(|| {
+            let initial_value = <GrowthEnabled<Test>>::get();
+            let new_growth_enabled_setting =
+                AdminSettings::<BalanceOf<Test>>::GrowthEnabled(initial_value);
+
+            assert_ok!(ParachainStaking::set_admin_setting(
+                Origin::root(),
+                new_growth_enabled_setting.clone()
+            ));
+
+            assert_eq!(<GrowthEnabled<Test>>::get(), initial_value);
+            assert_last_event!(MetaEvent::ParachainStaking(Event::AdminSettingsUpdated {
+                value: new_growth_enabled_setting
+            }));
+        });
+    }
+}

pallets/parachain-staking/src/tests/test_growth.rs

@@ -1,12 +1,12 @@
 use crate::{
-    assert_event_emitted,
+    assert_event_emitted, assert_last_event,
     mock::{
         get_default_block_per_era, roll_one_block, roll_to_era_begin, set_author, set_reward_pot,
         AccountId, Balances, ErasPerGrowthPeriod, ExtBuilder, ParachainStaking, RewardPaymentDelay,
-        RuntimeOrigin, System, Test, TestAccount,
+        RuntimeEvent, RuntimeOrigin, System, Test, TestAccount,
     },
-    BalanceOf, CollatorScore, EraIndex, Error, Event, Growth, GrowthInfo, GrowthPeriod,
-    GrowthPeriodInfo, ProcessedGrowthPeriods,
+    AdminSettings, BalanceOf, CollatorScore, EraIndex, Error, Event, Growth, GrowthEnabled,
+    GrowthInfo, GrowthPeriod, GrowthPeriodInfo, ProcessedGrowthPeriods,
 };
 use codec::{Decode, Encode};
 use frame_support::{assert_noop, assert_ok};
@@ -67,6 +67,19 @@ fn increase_collator_nomination(
     ));
 }
 
+fn disable_growth() {
+    let new_growth_enabled_setting = AdminSettings::<BalanceOf<Test>>::GrowthEnabled(false);
+    assert_ok!(ParachainStaking::set_admin_setting(
+        RuntimeOrigin::root(),
+        new_growth_enabled_setting.clone()
+    ));
+
+    assert_eq!(<GrowthEnabled<Test>>::get(), false);
+    assert_last_event!(RuntimeEvent::ParachainStaking(Event::AdminSettingsUpdated {
+        value: new_growth_enabled_setting
+    }));
+}
+
 fn get_expected_block_number(growth_index: u64) -> u64 {
     return get_default_block_per_era() as u64 * ErasPerGrowthPeriod::get() as u64 * growth_index
 }
@@ -200,6 +213,68 @@ fn growth_period_indices_updated_correctly() {
         });
 }
 
+mod growth_disabled {
+    use super::*;
+
+    #[test]
+    fn growth_period_indices_are_not_updated() {
+        let collator_1 = to_acc_id(1u64);
+        let collator_2 = to_acc_id(2u64);
+        ExtBuilder::default()
+            .with_balances(vec![(collator_1, 100), (collator_2, 100)])
+            .with_candidates(vec![(collator_1, 10), (collator_2, 10)])
+            .build()
+            .execute_with(|| {
+                disable_growth();
+                let initial_growth_period_index = 0;
+                let mut era_index = ParachainStaking::era().current;
+
+                set_author(era_index, collator_1, 5);
+                set_author(era_index, collator_2, 5);
+                era_index = roll_one_growth_period(era_index);
+
+                let growth_period_info = ParachainStaking::growth_period_info();
+                // ensure indice is not updated
+                assert_eq!(initial_growth_period_index, growth_period_info.start_era_index);
+            });
+    }
+
+    #[test]
+    fn growth_info_is_not_updated() {
+        let collator_1 = to_acc_id(1u64);
+        let collator_2 = to_acc_id(2u64);
+        let collator1_stake = 20;
+        let collator2_stake = 10;
+        let reward_payment_delay = RewardPaymentDelay::get();
+        ExtBuilder::default()
+            .with_balances(vec![(collator_1, 10000), (collator_2, 10000)])
+            .with_candidates(vec![(collator_1, collator1_stake), (collator_2, collator2_stake)])
+            .build()
+            .execute_with(|| {
+                disable_growth();
+                let num_era_to_roll_foreward = reward_payment_delay + 1;
+
+                // Setup data by rolling forward and letting the system generate staking rewards.
+                // This is not "faked" data.
+                let raw_era_data: HashMap<EraIndex, GrowthData> = roll_foreward_and_pay_stakers(
+                    num_era_to_roll_foreward,
+                    collator_1,
+                    collator_2,
+                    collator1_stake,
+                    collator2_stake,
+                );
+
+                let growth = ParachainStaking::growth(1);
+                // Ensure info is not updated
+                assert_eq!(growth.number_of_accumulations, 0);
+                assert_eq!(growth.total_points, 0);
+                assert_eq!(growth.total_stake_accumulated, 0);
+                assert_eq!(growth.total_staker_reward, 0);
+                assert_eq!(growth.collator_scores.len(), 0);
+            });
+    }
+}
+
 mod growth_info_recorded_correctly {
     use super::*;
 

pallets/parachain-staking/src/types.rs

@@ -1427,6 +1427,8 @@ pub enum AdminSettings<Balance> {
     MinCollatorStake(Balance),
     /// Minimum nominator stake amount
     MinTotalNominatorStake(Balance),
+    /// Growth enabled flag
+    GrowthEnabled(bool),
 }
 
 impl<
@@ -1451,6 +1453,7 @@ impl<
             AdminSettings::MinTotalNominatorStake(s) =>
                 s >= &<<T as Config>::MinNominationPerCollator as Get<BalanceOf<T>>>::get().into(),
             AdminSettings::MinCollatorStake(_) => true,
+            AdminSettings::GrowthEnabled(_) => true,
             _ => false,
         }
     }

pallets/token-manager/src/mock.rs

@@ -262,6 +262,7 @@ parameter_types! {
     pub const RewardPaymentDelay: u32 = 2;
     pub const RewardPotId: PalletId = PalletId(*b"av/vamgr");
     pub const MaxCandidates: u32 = 100;
+    pub const GrowthEnabled: bool = true;
 }
 
 impl parachain_staking::Config for TestRuntime {
@@ -286,6 +287,7 @@ impl parachain_staking::Config for TestRuntime {
     type MaxCandidates = MaxCandidates;
     type AccountToBytesConvert = AVN;
     type BridgeInterface = EthBridge;
+    type GrowthEnabled = GrowthEnabled;
 }
 
 impl pallet_session::historical::Config for TestRuntime {
@@ -439,6 +441,7 @@ impl ExtBuilder {
             delay: 2,
             min_collator_stake: 10,
             min_total_nominator_stake: 5,
+            growth_enabled: true,
         }
         .assimilate_storage(&mut self.storage);
 

pallets/validators-manager/src/tests/mock.rs

@@ -296,6 +296,7 @@ parameter_types! {
     pub const RewardPaymentDelay: u32 = 2;
     pub const RewardPotId: PalletId = PalletId(*b"av/vamgr");
     pub const MaxCandidates: u32 = 256;
+    pub const GrowthEnabled: bool = true;
 }
 
 impl parachain_staking::Config for TestRuntime {
@@ -320,6 +321,7 @@ impl parachain_staking::Config for TestRuntime {
     type MaxCandidates = MaxCandidates;
     type AccountToBytesConvert = AVN;
     type BridgeInterface = EthBridge;
+    type GrowthEnabled = GrowthEnabled;
 }
 
 /// An extrinsic type used for tests.
@@ -502,6 +504,7 @@ impl ExtBuilder {
             delay: 2,
             min_collator_stake: 10,
             min_total_nominator_stake: 5,
+            growth_enabled: true,
         }
         .assimilate_storage(&mut self.storage);
 

runtime/avn/src/lib.rs

@@ -452,6 +452,7 @@ impl pallet_parachain_staking::Config for Runtime {
     type MaxCandidates = ConstU32<100>;
     type AccountToBytesConvert = Avn;
     type BridgeInterface = EthBridge;
+    type GrowthEnabled = ConstBool<true>;
 }
 
 // Substrate pallets that AvN has dependency

runtime/test/src/lib.rs

@@ -470,6 +470,7 @@ impl pallet_parachain_staking::Config for Runtime {
     type MaxCandidates = ConstU32<100>;
     type AccountToBytesConvert = Avn;
     type BridgeInterface = EthBridge;
+    type GrowthEnabled = ConstBool<true>;
 }
 
 // Substrate pallets that AvN has dependency