Base native currency price for dApp Staking

pallets/dapp-staking-v3/src/benchmarking/utils.rs

@@ -197,13 +197,14 @@ pub(super) fn init_tier_settings<T: Config>() {
     };
 
     // Init tier config, based on the initial params
-    let init_tier_config = TiersConfiguration::<T::NumberOfTiers, T::TierSlots> {
-        number_of_slots: NUMBER_OF_SLOTS.try_into().unwrap(),
-        slots_per_tier: BoundedVec::try_from(vec![10, 20, 30, 40]).unwrap(),
-        reward_portion: tier_params.reward_portion.clone(),
-        tier_thresholds: tier_params.tier_thresholds.clone(),
-        _phantom: Default::default(),
-    };
+    let init_tier_config =
+        TiersConfiguration::<T::NumberOfTiers, T::TierSlots, T::BaseNativeCurrencyPrice> {
+            number_of_slots: NUMBER_OF_SLOTS.try_into().unwrap(),
+            slots_per_tier: BoundedVec::try_from(vec![10, 20, 30, 40]).unwrap(),
+            reward_portion: tier_params.reward_portion.clone(),
+            tier_thresholds: tier_params.tier_thresholds.clone(),
+            _phantom: Default::default(),
+        };
 
     assert!(tier_params.is_valid());
     assert!(init_tier_config.is_valid());

pallets/dapp-staking-v3/src/lib.rs

@@ -44,6 +44,7 @@ use frame_support::{
     weights::Weight,
 };
 use frame_system::pallet_prelude::*;
+use sp_arithmetic::fixed_point::FixedU128;
 use sp_runtime::{
     traits::{BadOrigin, One, Saturating, UniqueSaturatedInto, Zero},
     Perbill, Permill, SaturatedConversion,
@@ -148,6 +149,11 @@ pub mod pallet {
         /// Used to calculate total number of tier slots for some price.
         type TierSlots: TierSlotFunc;
 
+        /// Base native currency price used to calculate base number of slots.
+        /// This is used to adjust tier configuration, tier thresholds specifically, based on the native token price changes.
+        #[pallet::constant]
+        type BaseNativeCurrencyPrice: Get<FixedU128>;
+
         /// Maximum length of a single era reward span length entry.
         #[pallet::constant]
         type EraRewardSpanLength: Get<u32>;
@@ -446,8 +452,11 @@ pub mod pallet {
 
     /// Tier configuration user for current & preceding eras.
     #[pallet::storage]
-    pub type TierConfig<T: Config> =
-        StorageValue<_, TiersConfiguration<T::NumberOfTiers, T::TierSlots>, ValueQuery>;
+    pub type TierConfig<T: Config> = StorageValue<
+        _,
+        TiersConfiguration<T::NumberOfTiers, T::TierSlots, T::BaseNativeCurrencyPrice>,
+        ValueQuery,
+    >;
 
     /// Information about which tier a dApp belonged to in a specific era.
     #[pallet::storage]
@@ -509,16 +518,17 @@ pub mod pallet {
             let number_of_slots = self.slots_per_tier.iter().fold(0_u16, |acc, &slots| {
                 acc.checked_add(slots).expect("Overflow")
             });
-            let tier_config = TiersConfiguration::<T::NumberOfTiers, T::TierSlots> {
-                number_of_slots,
-                slots_per_tier: BoundedVec::<u16, T::NumberOfTiers>::try_from(
-                    self.slots_per_tier.clone(),
-                )
-                .expect("Invalid number of slots per tier entries provided."),
-                reward_portion: tier_params.reward_portion.clone(),
-                tier_thresholds: tier_params.tier_thresholds.clone(),
-                _phantom: Default::default(),
-            };
+            let tier_config =
+                TiersConfiguration::<T::NumberOfTiers, T::TierSlots, T::BaseNativeCurrencyPrice> {
+                    number_of_slots,
+                    slots_per_tier: BoundedVec::<u16, T::NumberOfTiers>::try_from(
+                        self.slots_per_tier.clone(),
+                    )
+                    .expect("Invalid number of slots per tier entries provided."),
+                    reward_portion: tier_params.reward_portion.clone(),
+                    tier_thresholds: tier_params.tier_thresholds.clone(),
+                    _phantom: Default::default(),
+                };
             assert!(
                 tier_params.is_valid(),
                 "Invalid tier config values provided."

pallets/dapp-staking-v3/src/test/mock.rs

@@ -115,7 +115,7 @@ impl PriceProvider for DummyPriceProvider {
 thread_local! {
     pub(crate) static DOES_PAYOUT_SUCCEED: RefCell<bool> = RefCell::new(false);
     pub(crate) static BLOCK_BEFORE_NEW_ERA: RefCell<EraNumber> = RefCell::new(0);
-    pub(crate) static NATIVE_PRICE: RefCell<FixedU128> = RefCell::new(FixedU128::from_rational(1, 10));
+    pub(crate) static NATIVE_PRICE: RefCell<FixedU128> = RefCell::new(BaseNativeCurrencyPrice::get());
 }
 
 pub struct DummyStakingRewardHandler;
@@ -195,6 +195,10 @@ impl AccountCheck<AccountId> for DummyAccountCheck {
     }
 }
 
+parameter_types! {
+    pub const BaseNativeCurrencyPrice: FixedU128 = FixedU128::from_rational(5, 100);
+}
+
 impl pallet_dapp_staking::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type RuntimeFreezeReason = RuntimeFreezeReason;
@@ -207,6 +211,7 @@ impl pallet_dapp_staking::Config for Test {
     type Observers = DummyDappStakingObserver;
     type AccountCheck = DummyAccountCheck;
     type TierSlots = StandardTierSlots;
+    type BaseNativeCurrencyPrice = BaseNativeCurrencyPrice;
     type EraRewardSpanLength = ConstU32<8>;
     type RewardRetentionInPeriods = ConstU32<2>;
     type MaxNumberOfContracts = ConstU32<10>;
@@ -315,6 +320,7 @@ impl ExtBuilder {
             let init_tier_config = TiersConfiguration::<
                 <Test as Config>::NumberOfTiers,
                 <Test as Config>::TierSlots,
+                <Test as Config>::BaseNativeCurrencyPrice,
             > {
                 number_of_slots: 40,
                 slots_per_tier: BoundedVec::try_from(vec![2, 5, 13, 20]).unwrap(),

pallets/dapp-staking-v3/src/test/tests.rs

@@ -35,7 +35,7 @@ use frame_support::{
 use sp_runtime::{traits::Zero, FixedU128};
 
 use astar_primitives::{
-    dapp_staking::{CycleConfiguration, EraNumber, SmartContractHandle},
+    dapp_staking::{CycleConfiguration, EraNumber, SmartContractHandle, TierSlots},
     Balance, BlockNumber,
 };
 
@@ -3022,3 +3022,92 @@ fn safeguard_configurable_by_genesis_config() {
         assert!(Safeguard::<Test>::get());
     });
 }
+
+#[test]
+fn base_number_of_slots_is_respected() {
+    ExtBuilder::build().execute_with(|| {
+        // 0. Get expected number of slots for the base price
+        let base_native_price = <Test as Config>::BaseNativeCurrencyPrice::get();
+        let base_number_of_slots = <Test as Config>::TierSlots::number_of_slots(base_native_price);
+
+        // 1. Make sure base native price is set initially and calculate the new config. Store the thresholds for later comparison.
+        NATIVE_PRICE.with(|v| *v.borrow_mut() = base_native_price);
+        assert_ok!(DappStaking::force(RuntimeOrigin::root(), ForcingType::Era));
+        run_for_blocks(1);
+
+        assert_eq!(
+            TierConfig::<Test>::get().number_of_slots,
+            base_number_of_slots,
+            "Base number of slots is expected for base native currency price."
+        );
+
+        let base_thresholds = TierConfig::<Test>::get().tier_thresholds;
+
+        // 2. Increase the price significantly, and ensure number of slots has increased, and thresholds have been saturated.
+        NATIVE_PRICE.with(|v| *v.borrow_mut() = base_native_price * FixedU128::from(1000));
+        assert_ok!(DappStaking::force(RuntimeOrigin::root(), ForcingType::Era));
+        run_for_blocks(1);
+
+        assert!(
+            TierConfig::<Test>::get().number_of_slots > base_number_of_slots,
+            "Price has increased, therefore number of slots must increase."
+        );
+
+        for tier_threshold in TierConfig::<Test>::get().tier_thresholds.iter() {
+            if let TierThreshold::DynamicTvlAmount {
+                amount,
+                minimum_amount,
+            } = tier_threshold
+            {
+                assert_eq!(*amount, *minimum_amount, "Thresholds must be saturated.");
+            }
+        }
+
+        // 3. Bring it back down to the base price, and expect number of slots to be the same as the base number of slots,
+        // and thresholds to be the same as the base thresholds.
+        NATIVE_PRICE.with(|v| *v.borrow_mut() = base_native_price);
+        assert_ok!(DappStaking::force(RuntimeOrigin::root(), ForcingType::Era));
+        run_for_blocks(1);
+
+        assert_eq!(
+            TierConfig::<Test>::get().number_of_slots,
+            base_number_of_slots,
+            "Base number of slots is expected for base native currency price."
+        );
+
+        assert_eq!(
+            TierConfig::<Test>::get().tier_thresholds,
+            base_thresholds,
+            "Thresholds must be the same as the base thresholds."
+        );
+
+        // 4. Bring it below the base price, and expect number of slots to decrease.
+        NATIVE_PRICE
+            .with(|v| *v.borrow_mut() = base_native_price * FixedU128::from_rational(1, 1000));
+        assert_ok!(DappStaking::force(RuntimeOrigin::root(), ForcingType::Era));
+        run_for_blocks(1);
+
+        assert!(
+            TierConfig::<Test>::get().number_of_slots < base_number_of_slots,
+            "Price has decreased, therefore number of slots must decrease."
+        );
+
+        // 5. Bring it back to the base price, and expect number of slots to be the same as the base number of slots,
+        // and thresholds to be the same as the base thresholds.
+        NATIVE_PRICE.with(|v| *v.borrow_mut() = base_native_price);
+        assert_ok!(DappStaking::force(RuntimeOrigin::root(), ForcingType::Era));
+        run_for_blocks(1);
+
+        assert_eq!(
+            TierConfig::<Test>::get().number_of_slots,
+            base_number_of_slots,
+            "Base number of slots is expected for base native currency price."
+        );
+
+        assert_eq!(
+            TierConfig::<Test>::get().tier_thresholds,
+            base_thresholds,
+            "Thresholds must be the same as the base thresholds."
+        );
+    })
+}

pallets/dapp-staking-v3/src/test/tests_types.rs

@@ -17,7 +17,7 @@
 // along with Astar. If not, see <http://www.gnu.org/licenses/>.
 
 use astar_primitives::{dapp_staking::StandardTierSlots, Balance};
-use frame_support::assert_ok;
+use frame_support::{assert_ok, parameter_types};
 use sp_arithmetic::fixed_point::FixedU128;
 use sp_runtime::Permill;
 
@@ -2877,7 +2877,10 @@ fn tier_configuration_basic_tests() {
     assert!(params.is_valid(), "Example params must be valid!");
 
     // Create a configuration with some values
-    let init_config = TiersConfiguration::<TiersNum, StandardTierSlots> {
+    parameter_types! {
+        pub const BaseNativeCurrencyPrice: FixedU128 = FixedU128::from_rational(5, 100);
+    }
+    let init_config = TiersConfiguration::<TiersNum, StandardTierSlots, BaseNativeCurrencyPrice> {
         number_of_slots: 100,
         slots_per_tier: BoundedVec::try_from(vec![10, 20, 30, 40]).unwrap(),
         reward_portion: params.reward_portion.clone(),

pallets/dapp-staking-v3/src/types.rs

@@ -1579,8 +1579,8 @@ impl<NT: Get<u32>> Default for TierParameters<NT> {
     CloneNoBound,
     TypeInfo,
 )]
-#[scale_info(skip_type_params(NT, T))]
-pub struct TiersConfiguration<NT: Get<u32>, T: TierSlotsFunc> {
+#[scale_info(skip_type_params(NT, T, P))]
+pub struct TiersConfiguration<NT: Get<u32>, T: TierSlotsFunc, P: Get<FixedU128>> {
     /// Total number of slots.
     #[codec(compact)]
     pub number_of_slots: u16,
@@ -1596,10 +1596,10 @@ pub struct TiersConfiguration<NT: Get<u32>, T: TierSlotsFunc> {
     pub tier_thresholds: BoundedVec<TierThreshold, NT>,
     /// Phantom data to keep track of the tier slots function.
     #[codec(skip)]
-    pub(crate) _phantom: PhantomData<T>,
+    pub(crate) _phantom: PhantomData<(T, P)>,
 }
 
-impl<NT: Get<u32>, T: TierSlotsFunc> Default for TiersConfiguration<NT, T> {
+impl<NT: Get<u32>, T: TierSlotsFunc, P: Get<FixedU128>> Default for TiersConfiguration<NT, T, P> {
     fn default() -> Self {
         Self {
             number_of_slots: 0,
@@ -1616,7 +1616,7 @@ impl<NT: Get<u32>, T: TierSlotsFunc> Default for TiersConfiguration<NT, T> {
 // * There's no need to keep thresholds in two separate storage items since the calculation can always be done compared to the
 //    anchor value of 5 cents. This still needs to be checked & investigated, but it's worth a try.
 
-impl<NT: Get<u32>, T: TierSlotsFunc> TiersConfiguration<NT, T> {
+impl<NT: Get<u32>, T: TierSlotsFunc, P: Get<FixedU128>> TiersConfiguration<NT, T, P> {
     /// Check if parameters are valid.
     pub fn is_valid(&self) -> bool {
         let number_of_tiers: usize = NT::get() as usize;
@@ -1651,10 +1651,12 @@ impl<NT: Get<u32>, T: TierSlotsFunc> TiersConfiguration<NT, T> {
         //
         // According to formula: %_threshold = (100% / (100% - delta_%_slots) - 1) * 100%
         //
-        // where delta_%_slots is simply: (old_num_slots - new_num_slots) / old_num_slots
+        // where delta_%_slots is simply: (base_num_slots - new_num_slots) / base_num_slots
+        //
+        // `base_num_slots` is the number of slots at the base native currency price.
         //
         // When these entries are put into the threshold formula, we get:
-        // = 1 / ( 1 - (old_num_slots - new_num_slots) / old_num_slots ) - 1
+        // = 1 / ( 1 - (base_num_slots - new_num_slots) / base_num_slots ) - 1
         // = 1 / ( new / old) - 1
         // = old / new - 1
         // = (old - new) / new
@@ -1663,20 +1665,24 @@ impl<NT: Get<u32>, T: TierSlotsFunc> TiersConfiguration<NT, T> {
         // formulas are adjusted like:
         //
         // 1. Number of slots has increased, threshold is expected to decrease
-        // %_threshold = (new_num_slots - old_num_slots) / new_num_slots
-        // new_threshold = old_threshold * (1 - %_threshold)
+        // %_threshold = (new_num_slots - base_num_slots) / new_num_slots
+        // new_threshold = base_threshold * (1 - %_threshold)
         //
         // 2. Number of slots has decreased, threshold is expected to increase
-        // %_threshold = (old_num_slots - new_num_slots) / new_num_slots
-        // new_threshold = old_threshold * (1 + %_threshold)
+        // %_threshold = (base_num_slots - new_num_slots) / new_num_slots
+        // new_threshold = base_threshold * (1 + %_threshold)
         //
-        let new_tier_thresholds = if new_number_of_slots > self.number_of_slots {
+        let base_number_of_slots = T::number_of_slots(P::get()).max(1);
+
+        // NOTE: even though we could ignore the situation when the new & base slot numbers are equal, it's necessary to re-calculate it since
+        // other params related to calculation might have changed.
+        let new_tier_thresholds = if new_number_of_slots >= base_number_of_slots {
             let delta_threshold_decrease = FixedU128::from_rational(
-                (new_number_of_slots - self.number_of_slots).into(),
+                (new_number_of_slots - base_number_of_slots).into(),
                 new_number_of_slots.into(),
             );
 
-            let mut new_tier_thresholds = self.tier_thresholds.clone();
+            let mut new_tier_thresholds = params.tier_thresholds.clone();
             new_tier_thresholds
                 .iter_mut()
                 .for_each(|threshold| match threshold {
@@ -1692,13 +1698,13 @@ impl<NT: Get<u32>, T: TierSlotsFunc> TiersConfiguration<NT, T> {
                 });
 
             new_tier_thresholds
-        } else if new_number_of_slots < self.number_of_slots {
+        } else {
             let delta_threshold_increase = FixedU128::from_rational(
-                (self.number_of_slots - new_number_of_slots).into(),
+                (base_number_of_slots - new_number_of_slots).into(),
                 new_number_of_slots.into(),
             );
 
-            let mut new_tier_thresholds = self.tier_thresholds.clone();
+            let mut new_tier_thresholds = params.tier_thresholds.clone();
             new_tier_thresholds
                 .iter_mut()
                 .for_each(|threshold| match threshold {
@@ -1710,8 +1716,6 @@ impl<NT: Get<u32>, T: TierSlotsFunc> TiersConfiguration<NT, T> {
                 });
 
             new_tier_thresholds
-        } else {
-            self.tier_thresholds.clone()
         };
 
         Self {

precompiles/dapp-staking-v3/src/test/mock.rs

@@ -245,6 +245,10 @@ impl pallet_dapp_staking_v3::BenchmarkHelper<MockSmartContract, AccountId>
     fn set_balance(_account: &AccountId, _amount: Balance) {}
 }
 
+parameter_types! {
+    pub const BaseNativeCurrencyPrice: FixedU128 = FixedU128::from_rational(5, 100);
+}
+
 impl pallet_dapp_staking_v3::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type RuntimeFreezeReason = RuntimeFreezeReason;
@@ -257,6 +261,7 @@ impl pallet_dapp_staking_v3::Config for Test {
     type Observers = ();
     type AccountCheck = ();
     type TierSlots = StandardTierSlots;
+    type BaseNativeCurrencyPrice = BaseNativeCurrencyPrice;
     type EraRewardSpanLength = ConstU32<8>;
     type RewardRetentionInPeriods = ConstU32<2>;
     type MaxNumberOfContracts = ConstU32<10>;

runtime/astar/src/lib.rs

@@ -64,7 +64,7 @@ use sp_runtime::{
         DispatchInfoOf, Dispatchable, OpaqueKeys, PostDispatchInfoOf, UniqueSaturatedInto, Zero,
     },
     transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},
-    ApplyExtrinsicResult, FixedPointNumber, Perbill, Permill, Perquintill, RuntimeDebug,
+    ApplyExtrinsicResult, FixedPointNumber, FixedU128, Perbill, Permill, Perquintill, RuntimeDebug,
 };
 use sp_std::{collections::btree_map::BTreeMap, prelude::*};
 
@@ -326,6 +326,7 @@ impl pallet_multisig::Config for Runtime {
 
 parameter_types! {
     pub const MinimumStakingAmount: Balance = 500 * ASTR;
+    pub const BaseNativeCurrencyPrice: FixedU128 = FixedU128::from_rational(5, 100);
 }
 
 #[cfg(feature = "runtime-benchmarks")]
@@ -368,6 +369,7 @@ impl pallet_dapp_staking_v3::Config for Runtime {
     type Observers = Inflation;
     type AccountCheck = AccountCheck;
     type TierSlots = StandardTierSlots;
+    type BaseNativeCurrencyPrice = BaseNativeCurrencyPrice;
     type EraRewardSpanLength = ConstU32<16>;
     type RewardRetentionInPeriods = ConstU32<4>;
     type MaxNumberOfContracts = ConstU32<500>;