make slow-clap tests work again based on new functionality, new tests added too

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

pallets/slow-clap/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-slow-clap"
-version = "0.3.43"
+version = "0.3.45"
 description = "Applause protocol for the EVM bridge"
 license.workspace = true
 authors.workspace = true

pallets/slow-clap/src/lib.rs

@@ -35,7 +35,11 @@ use sp_staking::{
     offence::{Kind, Offence, ReportOffence},
     SessionIndex,
 };
-use sp_std::{collections::btree_map::BTreeMap, prelude::*, vec::Vec};
+use sp_std::{
+    collections::{btree_map::BTreeMap, btree_set::BTreeSet},
+    prelude::*,
+    vec::Vec,
+};
 
 use ghost_networks::{
     NetworkData, NetworkDataBasicHandler, NetworkDataInspectHandler, NetworkDataMutateHandler,
@@ -238,7 +242,6 @@ pub mod pallet {
     #[pallet::error]
     pub enum Error<T> {
         NotEnoughClaps,
-        NotAnAuthority,
         CurrentValidatorIsDisabled,
         AlreadyClapped,
         UnregisteredClapRemove,
@@ -294,6 +297,16 @@ pub mod pallet {
         ValueQuery,
     >;
 
+    #[pallet::storage]
+    #[pallet::getter(fn validators)]
+    pub(super) type Validators<T: Config> = StorageMap<
+        _,
+        Twox64Concat,
+        SessionIndex,
+        WeakBoundedVec<ValidatorId<T>, T::MaxAuthorities>,
+        OptionQuery,
+    >;
+
     #[pallet::genesis_config]
     #[derive(frame_support::DefaultNoBound)]
     pub struct GenesisConfig<T: Config> {
@@ -330,7 +343,7 @@ pub mod pallet {
         pub fn self_applause(
             origin: OriginFor<T>,
             network_id: NetworkIdOf<T>,
-            session_index: SessionIndex,
+            prev_session_index: SessionIndex,
             transaction_hash: H256,
             receiver: T::AccountId,
             amount: BalanceOf<T>,
@@ -338,7 +351,7 @@ pub mod pallet {
             let _ = ensure_signed(origin)?;
             Self::applause_if_posible(
                 network_id,
-                session_index,
+                prev_session_index,
                 transaction_hash,
                 receiver,
                 amount,
@@ -604,29 +617,35 @@ impl<T: Config> Pallet<T> {
     ) -> DispatchResult {
         let curr_session_index = prev_session_index.saturating_add(1);
         let clap_unique_hash = Self::generate_unique_hash(&receiver, &amount, &network_id);
-        let prev_received_claps_key = (prev_session_index, &transaction_hash, &clap_unique_hash);
-        let curr_received_claps_key = (curr_session_index, &transaction_hash, &clap_unique_hash);
 
         let prev_authorities = Authorities::<T>::get(&prev_session_index);
         let curr_authorities = Authorities::<T>::get(&curr_session_index);
 
-        let prev_received_claps = ReceivedClaps::<T>::get(&prev_received_claps_key).into_inner();
+        let prev_received_claps_key = (prev_session_index, &transaction_hash, &clap_unique_hash);
-        let curr_received_claps = ReceivedClaps::<T>::get(&curr_received_claps_key).into_inner();
+        let curr_received_claps_key = (curr_session_index, &transaction_hash, &clap_unique_hash);
+
+        let prev_received_claps = ReceivedClaps::<T>::get(&prev_received_claps_key)
+            .into_iter()
+            .filter_map(|auth_index| prev_authorities.get(auth_index as usize))
+            .cloned()
+            .collect::<BTreeSet<T::AuthorityId>>();
+
+        let curr_received_claps = ReceivedClaps::<T>::get(&curr_received_claps_key)
+            .into_iter()
+            .filter_map(|auth_index| curr_authorities.get(auth_index as usize))
+            .cloned()
+            .collect::<BTreeSet<T::AuthorityId>>();
+
+        let disabled_authorites = ClapsInSession::<T>::get(&prev_session_index)
+            .values()
+            .filter(|info| info.disabled)
+            .count();
+
+        let active_authorities = prev_authorities.len().saturating_sub(disabled_authorites);
 
         let summary_authority_claps_length = curr_received_claps
-            .difference(&prev_received_claps)
+            .symmetric_difference(&prev_received_claps)
-            .filter_map(|&index| {
+            .count();
-                curr_authorities
-                    .get(index as usize)
-                    .map(|curr_authority| {
-                        prev_authorities
-                            .iter()
-                            .position(|prev_authority| curr_authority == prev_authority)
-                    })
-                    .flatten()
-            })
-            .count()
-            .saturating_add(curr_received_claps.len());
 
         let clap = Clap {
             authority_index: Default::default(),
@@ -641,7 +660,7 @@ impl<T: Config> Pallet<T> {
 
         let enough_authorities = Perbill::from_rational(
             summary_authority_claps_length as u32,
-            Authorities::<T>::get(prev_session_index).len() as u32,
+            active_authorities as u32,
         ) > Perbill::from_percent(T::ApplauseThreshold::get());
 
         ensure!(enough_authorities, Error::<T>::NotEnoughClaps);
@@ -1075,16 +1094,23 @@ impl<T: Config> Pallet<T> {
         let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities)
             .expect("more than the maximum number of authorities");
 
+        let validators = T::ValidatorSet::validators();
+        let bounded_validators = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(validators)
+            .expect("more than the maximum number of validators");
+
         if let Some(target_session_index) = session_index.checked_sub(T::HistoryDepth::get()) {
             Self::clear_history(&target_session_index);
         }
 
+        Validators::<T>::insert(&session_index, bounded_validators);
         Authorities::<T>::set(&session_index, bounded_authorities);
         ClapsInSession::<T>::set(&session_index, Default::default());
     }
 
     fn clear_history(target_session_index: &SessionIndex) {
         ClapsInSession::<T>::remove(target_session_index);
+        Authorities::<T>::remove(target_session_index);
+        Validators::<T>::remove(target_session_index);
         let mut cursor = ReceivedClaps::<T>::clear_prefix((target_session_index,), u32::MAX, None);
         debug_assert!(cursor.maybe_cursor.is_none());
         cursor =
@@ -1136,8 +1162,8 @@ impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
     }
 
     fn on_before_session_ending() {
-        let validators = T::ValidatorSet::validators();
         let session_index = T::ValidatorSet::session_index().saturating_sub(1);
+        let validators = Validators::<T>::get(&session_index).unwrap_or_default();
         let authorities_len = Authorities::<T>::get(&session_index).len();
         let claps_in_session = ClapsInSession::<T>::get(&session_index);
 

pallets/slow-clap/src/tests.rs

@@ -665,15 +665,14 @@ fn should_throw_error_if_session_index_is_not_current() {
                 network_id,
                 authority_prev
             ));
-            assert_ok!(do_clap_from_first_authority(
+            assert_err!(
-                session_index_next,
+                do_clap_from_first_authority(session_index_next, network_id, authority_next),
-                network_id,
+                DispatchError::Other("Transaction has a bad signature")
-                authority_next
+            );
-            ));
 
             assert_claps_info_correct(&storage_key_curr, &session_index_curr, 1);
             assert_claps_info_correct(&storage_key_prev, &session_index_prev, 1);
-            assert_claps_info_correct(&storage_key_next, &session_index_next, 1);
+            assert_claps_info_correct(&storage_key_next, &session_index_next, 0);
         }
     });
 }
@@ -688,22 +687,12 @@ fn should_throw_error_if_signer_has_incorrect_index() {
         let storage_key = (session_index, transaction_hash, unique_transaction_hash);
 
         assert_claps_info_correct(&storage_key, &session_index, 0);
-        let clap = Clap {
+        assert_invalid_signing_address(session_index, network_id, 69);
-            block_number: 420,
+        assert_transaction_has_bad_signature(session_index, network_id, 69);
-            removed: false,
+        assert_invalid_signing_address(session_index, network_id, 420);
-            transaction_hash,
+        assert_transaction_has_bad_signature(session_index, network_id, 420);
-            session_index,
+        assert_invalid_signing_address(session_index, network_id, 1337);
-            authority_index: 1337,
+        assert_transaction_has_bad_signature(session_index, network_id, 1337);
-            network_id,
-            receiver: 69,
-            amount: 420,
-        };
-        let authority = UintAuthorityId::from((1) as u64);
-        let signature = authority.sign(&clap.encode()).unwrap();
-        assert_err!(
-            SlowClap::slow_clap(RuntimeOrigin::none(), clap, signature),
-            Error::<Runtime>::NotAnAuthority
-        );
         assert_claps_info_correct(&storage_key, &session_index, 0);
     });
 }
@@ -956,8 +945,8 @@ fn should_avoid_applause_during_nullification_period() {
 }
 
 #[test]
-fn should_self_applause_if_enough_received_claps() {
+fn should_self_applause_if_enough_claps() {
-    let zero: u64 = 0u64;
+    let zero = 0u64;
     let (network_id, transaction_hash, unique_transaction_hash) =
         generate_unique_hash(None, None, None, None);
     let (_, receiver, amount) = get_mocked_metadata();
@@ -965,6 +954,7 @@ fn should_self_applause_if_enough_received_claps() {
     new_test_ext().execute_with(|| {
         let _ = prepare_evm_network(Some(network_id), Some(0));
         let session_index = advance_session_and_get_index();
+        let next_session_index = session_index.saturating_add(1);
         let storage_key = (session_index, transaction_hash, unique_transaction_hash);
 
         assert_err!(
@@ -976,7 +966,7 @@ fn should_self_applause_if_enough_received_claps() {
                 receiver,
                 amount,
             ),
-            Error::<Runtime>::NotEnoughClaps
+            Error::<Runtime>::NotEnoughClaps,
         );
 
         assert_eq!(
@@ -984,59 +974,34 @@ fn should_self_applause_if_enough_received_claps() {
             false
         );
         assert_eq!(Balances::balance(&receiver), zero);
-        assert_eq!(
-            BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(zero, zero, zero),
-            (zero, zero)
-        );
 
         assert_ok!(do_clap_from(session_index, network_id, 0, false));
-        assert_ok!(do_clap_from(session_index, network_id, 1, false));
-
-        assert_eq!(
-            pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
-            false
-        );
-        assert_eq!(Balances::balance(&receiver), 0);
-
-        assert_err!(
-            SlowClap::self_applause(
-                RuntimeOrigin::signed(receiver),
-                network_id,
-                session_index,
-                transaction_hash,
-                receiver,
-                amount,
-            ),
-            Error::<Runtime>::NotEnoughClaps
-        );
-        assert_eq!(
-            pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
-            false
-        );
-        assert_eq!(Balances::balance(&receiver), 0);
-
-        Networks::on_finalize(System::block_number());
-
         advance_session();
-        let next_session_index = Session::session_index();
-        let next_storage_key = (
-            next_session_index,
-            transaction_hash,
-            unique_transaction_hash,
-        );
-        assert_ok!(do_clap_from(next_session_index, network_id, 2, false));
 
-        assert_err!(
+        let mut fake_claps_in_session = sp_std::collections::btree_map::BTreeMap::new();
-            SlowClap::self_applause(
+        fake_claps_in_session.insert(
-                RuntimeOrigin::signed(receiver),
+            1,
-                network_id,
+            SessionAuthorityInfo {
-                next_session_index,
+                claps: 1,
-                transaction_hash,
+                disabled: false,
-                receiver,
+            },
-                amount,
-            ),
-            Error::<Runtime>::NotEnoughClaps
         );
+        fake_claps_in_session.insert(
+            2,
+            SessionAuthorityInfo {
+                claps: 1,
+                disabled: false,
+            },
+        );
+
+        let mut fake_received_clap =
+            BoundedBTreeSet::<AuthIndex, <Runtime as pallet::Config>::MaxAuthorities>::new();
+        assert_eq!(fake_received_clap.try_insert(1).unwrap(), true);
+        assert_eq!(fake_received_clap.try_insert(2).unwrap(), true);
+
+        pallet::ReceivedClaps::<Runtime>::insert(&storage_key, fake_received_clap);
+        pallet::ClapsInSession::<Runtime>::insert(&next_session_index, fake_claps_in_session);
+
         assert_ok!(SlowClap::self_applause(
             RuntimeOrigin::signed(receiver),
             network_id,
@@ -1049,10 +1014,37 @@ fn should_self_applause_if_enough_received_claps() {
             pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
             true
         );
+        assert_eq!(Balances::balance(&receiver), amount);
+    });
+}
+
+#[test]
+fn should_avoid_session_overlap_on_mended_session_index() {
+    let (network_id, transaction_hash, unique_transaction_hash) =
+        generate_unique_hash(None, None, None, None);
+    let (_, receiver, amount) = get_mocked_metadata();
+
+    new_test_ext().execute_with(|| {
+        let _ = prepare_evm_network(Some(network_id), Some(0));
+        let session_index = advance_session_and_get_index();
+        let storage_key = (session_index, transaction_hash, unique_transaction_hash);
+
+        assert_ok!(do_clap_from(session_index, network_id, 0, false));
+        advance_session();
+
         assert_eq!(
-            pallet::ApplausesForTransaction::<Runtime>::get(&next_storage_key),
+            pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
             false
         );
+        assert_eq!(Balances::balance(&receiver), 0u64);
+
+        assert_ok!(do_clap_from(session_index, network_id, 1, false));
+        assert_ok!(do_clap_from(session_index, network_id, 2, false));
+
+        assert_eq!(
+            pallet::ApplausesForTransaction::<Runtime>::get(&storage_key),
+            true
+        );
         assert_eq!(Balances::balance(&receiver), amount);
     });
 }