remove unnecessary storage entry in pallet

Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>

pallets/networks/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-networks"
-version = "0.1.21"
+version = "0.1.22"
 license.workspace = true
 authors.workspace = true
 edition.workspace = true

pallets/networks/src/lib.rs

@@ -97,16 +97,14 @@ where
         _era_duration_in_millis: u64,
     ) -> (Balance, Balance) {
         let reward_curve = RewardCurve::get();
-        let bridged_imbalance = BridgedImbalance::<T>::get();
+        let bridged_imbalance = BridgedImbalance::<T>::take();
-        let accumulated_commission = AccumulatedCommission::<T>::get();
+        let accumulated_commission = AccumulatedCommission::<T>::take();
 
         let accumulated_commission: Balance = accumulated_commission.into();
         let adjusted_issuance: Balance = total_issuance
             .saturating_add(bridged_imbalance.bridged_out.into())
             .saturating_sub(bridged_imbalance.bridged_in.into());
 
-        NullifyNeeded::<T>::set(true);
-
         let estimated_reward =
             reward_curve.calculate_for_fraction_times_denominator(total_staked, adjusted_issuance);
 
@@ -243,10 +241,6 @@ pub mod module {
         },
     }
 
-    #[pallet::storage]
-    #[pallet::getter(fn nullify_needed)]
-    pub type NullifyNeeded<T: Config> = StorageValue<_, bool, ValueQuery>;
-
     #[pallet::storage]
     #[pallet::getter(fn bridged_imbalance)]
     pub type BridgedImbalance<T: Config> =
@@ -304,20 +298,6 @@ pub mod module {
     #[pallet::without_storage_info]
     pub struct Pallet<T>(PhantomData<T>);
 
-    #[pallet::hooks]
-    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
-        fn on_initialize(_: BlockNumberFor<T>) -> Weight {
-            T::DbWeight::get().reads_writes(1, 1)
-        }
-
-        fn on_finalize(_: BlockNumberFor<T>) {
-            if Self::nullify_needed() {
-                Self::nullify_commission();
-                NullifyNeeded::<T>::put(false);
-            }
-        }
-    }
-
     #[pallet::call]
     impl<T: Config> Pallet<T> {
         #[pallet::call_index(0)]
@@ -775,10 +755,6 @@ impl<T: Config> NetworkDataInspectHandler<NetworkData> for Pallet<T> {
     fn iter() -> PrefixIterator<(Self::NetworkId, NetworkData)> {
         Networks::<T>::iter()
     }
-
-    fn is_nullification_period() -> bool {
-        NullifyNeeded::<T>::get()
-    }
 }
 
 impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T> {
@@ -865,18 +841,4 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
             }
         })
     }
-
-    fn nullify_commission() {
-        AccumulatedCommission::<T>::set(Default::default());
-        BridgedImbalance::<T>::set(Default::default());
-    }
-
-    fn trigger_nullification() {
-        if NullifyNeeded::<T>::get() {
-            Self::nullify_commission();
-            NullifyNeeded::<T>::put(false);
-        } else {
-            NullifyNeeded::<T>::put(true);
-        }
-    }
 }

pallets/networks/src/migrations/v1.rs

@@ -1,10 +1,11 @@
 use frame_support::{
-    traits::{Get, UncheckedOnRuntimeUpgrade},
+    migration::clear_storage_prefix,
+    traits::{Get, PalletInfoAccess, UncheckedOnRuntimeUpgrade},
     weights::Weight,
 };
 use sp_std::marker::PhantomData;
 
-use crate::{BoundedVec, Config, NetworkIndexes, Networks, Vec, LOG_TARGET};
+use crate::{BoundedVec, Config, NetworkIndexes, Networks, Pallet, Vec, LOG_TARGET};
 
 pub struct StoreNetworkIdsIntoBoundedVec<T>(PhantomData<T>);
 impl<T: Config> UncheckedOnRuntimeUpgrade for StoreNetworkIdsIntoBoundedVec<T> {
@@ -16,6 +17,23 @@ impl<T: Config> UncheckedOnRuntimeUpgrade for StoreNetworkIdsIntoBoundedVec<T> {
 
         weight = weight.saturating_add(T::DbWeight::get().reads(networks_count as u64));
 
+        let clear_results = clear_storage_prefix(
+            Pallet::<T>::name().as_bytes(),
+            "NullifyNeeded".as_bytes(),
+            &[],
+            Some(1),
+            None,
+        );
+        log::info!(
+            target: LOG_TARGET,
+            "⛓️  NullifyNeeded storage succesfully removed: Loops (reads): {}, Unique removed (writes): {}",
+            clear_results.loops,
+            clear_results.unique,
+        );
+
+        weight = weight.saturating_add(T::DbWeight::get().reads(clear_results.loops as u64));
+        weight = weight.saturating_add(T::DbWeight::get().writes(clear_results.unique as u64));
+
         let writes = BoundedVec::<T::NetworkId, T::MaxNetworks>::try_from(network_ids)
             .inspect_err(|err| {
                 log::error!(

pallets/networks/src/tests.rs

@@ -1278,7 +1278,7 @@ fn bridged_amount_overflow_and_underflow_emits_error() {
 }
 
 #[test]
-fn accumulated_commission_could_be_nullified() {
+fn accumulated_commission_nullified_after_era_payout() {
     ExtBuilder::build().execute_with(|| {
         let commission_first: u128 = 420;
         let commission_second: u128 = 69;
@@ -1292,12 +1292,20 @@ fn accumulated_commission_could_be_nullified() {
             GhostNetworks::accumulate_commission(&commission_second,),
             commission_first + commission_second
         );
+
         assert_eq!(
             AccumulatedCommission::<Test>::get(),
             commission_first + commission_second
         );
-        GhostNetworks::nullify_commission();
+        assert_eq!(
+            BridgedInflationCurve::<RewardCurve, Test>::era_payout(1, 1, 1),
+            (0, commission_first + commission_second)
+        );
         assert_eq!(AccumulatedCommission::<Test>::get(), 0);
+        assert_eq!(
+            BridgedInflationCurve::<RewardCurve, Test>::era_payout(1, 1, 1),
+            (0, 0)
+        );
     });
 }
 
@@ -1385,7 +1393,6 @@ fn bridged_inlation_reward_works() {
 
         assert_ok!(GhostNetworks::accumulate_commission(&commission));
         assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
-
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 total_staked_ideal * 1_000,
@@ -1394,6 +1401,9 @@ fn bridged_inlation_reward_works() {
             ),
             (commission, 0)
         );
+
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 total_staked_ideal * 1_000_000_000_000,
@@ -1402,6 +1412,9 @@ fn bridged_inlation_reward_works() {
             ),
             (commission, 0)
         );
+
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 total_staked_ideal * 1_000_000_000_000_000_000_000_000,
@@ -1411,6 +1424,8 @@ fn bridged_inlation_reward_works() {
             (commission, 0)
         );
 
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 total_staked_not_ideal * 1_000,
@@ -1419,6 +1434,9 @@ fn bridged_inlation_reward_works() {
             ),
             (13177472000, 192528000)
         );
+
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(13177472000 + 192528000, commission);
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@@ -1428,6 +1446,9 @@ fn bridged_inlation_reward_works() {
             ),
             (13177568884, 192431116)
         );
+
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(13177568884 + 192431116, commission);
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@@ -1437,8 +1458,10 @@ fn bridged_inlation_reward_works() {
             ),
             (13177568884, 192431116)
         );
-        assert_eq!(13177568884 + 192431116, commission);
 
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
+        assert_eq!(13177568884 + 192431116, commission);
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 1,
@@ -1447,6 +1470,9 @@ fn bridged_inlation_reward_works() {
             ),
             (92386700, 13277613300)
         );
+
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(92386700 + 13277613300, commission);
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@@ -1456,6 +1482,9 @@ fn bridged_inlation_reward_works() {
             ),
             (92253000, 13277747000)
         );
+
+        assert_ok!(GhostNetworks::accumulate_commission(&commission));
+        assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
         assert_eq!(92253000 + 13277747000, commission);
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
@@ -1465,10 +1494,8 @@ fn bridged_inlation_reward_works() {
             ),
             (92253000, 13277747000)
         );
+
         assert_eq!(92253000 + 13277747000, commission);
-
-        GhostNetworks::nullify_commission();
-
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 total_staked_ideal * 1_000,
@@ -1547,7 +1574,7 @@ fn bridged_inlation_reward_works() {
 }
 
 #[test]
-fn bridged_inflation_era_payout_triggers_need_of_nullification() {
+fn bridged_inflation_era_payout_clears_storage() {
     ExtBuilder::build().execute_with(|| {
         let amount_full: u128 = 1337 * 1_000_000_000;
         let commission: u128 = amount_full / 100; // 1% commission
@@ -1558,7 +1585,13 @@ fn bridged_inflation_era_payout_triggers_need_of_nullification() {
 
         assert_ok!(GhostNetworks::accumulate_commission(&commission));
         assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
-        assert_eq!(NullifyNeeded::<Test>::get(), false);
+
+        let bridged_adjustment = BridgeAdjustment {
+            bridged_in: amount,
+            bridged_out: 0,
+        };
+        assert_eq!(BridgedImbalance::<Test>::get(), bridged_adjustment);
+        assert_eq!(AccumulatedCommission::<Test>::get(), commission);
         assert_eq!(
             BridgedInflationCurve::<RewardCurve, Test>::era_payout(
                 total_staked_ideal * 1_000,
@@ -1567,37 +1600,8 @@ fn bridged_inflation_era_payout_triggers_need_of_nullification() {
             ),
             (commission, 0)
         );
-        assert_eq!(NullifyNeeded::<Test>::get(), true);
+        assert_eq!(BridgedImbalance::<Test>::get(), Default::default());
-        GhostNetworks::on_finalize(69);
+        assert_eq!(AccumulatedCommission::<Test>::get(), Default::default());
-        assert_eq!(NullifyNeeded::<Test>::get(), false);
-    });
-}
-
-#[test]
-fn trigger_nullification_works_as_expected() {
-    ExtBuilder::build().execute_with(|| {
-        let commission: u128 = 69;
-        let imbalance = BridgeAdjustment {
-            bridged_in: 1337u128,
-            bridged_out: 420u128,
-        };
-
-        assert_eq!(AccumulatedCommission::<Test>::get(), 0);
-        assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment::default());
-
-        AccumulatedCommission::<Test>::set(commission);
-        BridgedImbalance::<Test>::set(imbalance.clone());
-
-        assert_eq!(AccumulatedCommission::<Test>::get(), commission);
-        assert_eq!(BridgedImbalance::<Test>::get(), imbalance);
-
-        assert_eq!(NullifyNeeded::<Test>::get(), false);
-        GhostNetworks::trigger_nullification();
-        assert_eq!(NullifyNeeded::<Test>::get(), true);
-        GhostNetworks::trigger_nullification();
-        assert_eq!(NullifyNeeded::<Test>::get(), false);
-        assert_eq!(AccumulatedCommission::<Test>::get(), 0);
-        assert_eq!(BridgedImbalance::<Test>::get(), BridgeAdjustment::default());
     });
 }
 
@@ -1680,7 +1684,6 @@ fn check_bridged_inflation_curve_for_overflow() {
         let commission: u128 = amount_full / 100; // 1% commission
         let amount: u128 = amount_full - commission;
 
-        let tollerance: u128 = commission / 100; // 1% tollerance
         let precomputed_payout: u128 = 13177568884;
         let precomputed_rest: u128 = 192431116;
         assert_eq!(precomputed_payout + precomputed_rest, commission);
@@ -1689,10 +1692,10 @@ fn check_bridged_inflation_curve_for_overflow() {
         let mut total_staked_not_ideal: u128 = 68_000;
         let mut total_issuance: u128 = 100_000;
 
+        loop {
             assert_ok!(GhostNetworks::accumulate_commission(&commission));
             assert_ok!(GhostNetworks::accumulate_incoming_imbalance(&amount));
 
-        loop {
             total_staked_ideal = match total_staked_ideal.checked_mul(1_000) {
                 Some(value) => value,
                 None => break,
@@ -1713,27 +1716,6 @@ fn check_bridged_inflation_curve_for_overflow() {
                 ),
                 (commission, 0)
             );
-
-            let (payout, rest) = BridgedInflationCurve::<RewardCurve, Test>::era_payout(
-                total_staked_not_ideal,
-                total_issuance + amount,
-                0,
-            );
-
-            let payout_deviation = if precomputed_payout > payout {
-                precomputed_payout - payout
-            } else {
-                payout - precomputed_payout
-            };
-
-            let rest_deviation = if precomputed_rest > rest {
-                precomputed_rest - rest
-            } else {
-                rest - precomputed_rest
-            };
-
-            assert!(payout_deviation < tollerance);
-            assert!(rest_deviation < tollerance);
         }
     });
 }
@@ -1796,6 +1778,17 @@ fn migration_from_v0_to_v1_works() {
         let (chain_id, network) = prepare_network_data();
         let other_chain_id = chain_id.saturating_add(1);
 
+        let removed_pallet_name = <Pallet<Test> as PalletInfoAccess>::name();
+        let removed_storage = "NullifyNeeded";
+
+        let key = [
+            sp_io::hashing::twox_128(removed_pallet_name.as_bytes()).to_vec(),
+            sp_io::hashing::twox_128(removed_storage.as_bytes()).to_vec(),
+        ]
+        .concat();
+
+        frame_support::storage::unhashed::put_raw(&key, &true.encode());
+
         assert_eq!(Networks::<Test>::get(chain_id), None);
         assert_ok!(GhostNetworks::register_network(
             RuntimeOrigin::signed(RegistererAccount::get()),
@@ -1809,12 +1802,15 @@ fn migration_from_v0_to_v1_works() {
         ));
         NetworkIndexes::<Test>::kill();
 
+        assert!(frame_support::storage::unhashed::exists(&key));
         assert_eq!(Networks::<Test>::get(chain_id), Some(network.clone()));
         assert_eq!(Networks::<Test>::get(other_chain_id), Some(network));
         assert_eq!(NetworkIndexes::<Test>::get(), vec![]);
 
         type Migrate = crate::migrations::MigrateV0ToV1<Test>;
         <Migrate as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade();
+
+        assert!(!frame_support::storage::unhashed::exists(&key));
         assert_eq!(
             NetworkIndexes::<Test>::get(),
             vec![chain_id, other_chain_id]