Cargo.lock

@@ -3648,7 +3648,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-networks"
-version = "0.1.5"
+version = "0.1.4"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3834,7 +3834,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-slow-clap"
-version = "0.3.23"
+version = "0.3.19"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3870,7 +3870,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-traits"
-version = "0.3.21"
+version = "0.3.20"
 dependencies = [
  "frame-support",
  "sp-runtime 31.0.1",

pallets/networks/Cargo.toml

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

pallets/networks/src/lib.rs

@@ -697,13 +697,4 @@ impl<T: Config> NetworkDataMutateHandler<NetworkData, BalanceOf<T>> for Pallet<T
     fn nullify_commission() {
         AccumulatedCommission::<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/tests.rs

@@ -935,15 +935,3 @@ fn bridged_inflation_era_payout_triggers_need_of_nullification() {
             assert_eq!(NullifyNeeded::<Test>::get(), false);
         });
 }
-
-#[test]
-fn trigger_nullification_works_as_expected() {
-    ExtBuilder::build()
-        .execute_with(|| {
-            assert_eq!(NullifyNeeded::<Test>::get(), false);
-            GhostNetworks::trigger_nullification();
-            assert_eq!(NullifyNeeded::<Test>::get(), true);
-            GhostNetworks::trigger_nullification();
-            assert_eq!(NullifyNeeded::<Test>::get(), false);
-        });
-}

pallets/slow-clap/Cargo.toml

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

pallets/slow-clap/src/benchmarking.rs

@@ -18,12 +18,12 @@ benchmarks! {
         let receiver = create_account::<T>();
         let amount = minimum_balance + minimum_balance;
         let network_id = NetworkIdOf::<T>::default();
-        let session_index = T::ValidatorSet::session_index();
 
         let authorities = vec![T::AuthorityId::generate_pair(None)];
-        let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities.clone())
+        let bounded_authorities = 
+            WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities.clone())
             .map_err(|()| "more than the maximum number of keys provided")?;
-        Authorities::<T>::set(&session_index, bounded_authorities);
+        Authorities::<T>::put(bounded_authorities);
 
         let clap = Clap {
             session_index: 0,
@@ -48,52 +48,6 @@ benchmarks! {
         assert_eq!(<<T as pallet::Config>::Currency>::total_balance(&receiver), amount);
     }
 
-    self_applause {
-        let session_index = T::ValidatorSet::session_index();
-        let authority = T::AuthorityId::generate_pair(Some(vec![69u8]));
-        let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(vec![authority.clone()])
-            .map_err(|()| "more than the maximum number of keys provided")?;
-        Authorities::<T>::set(&session_index, bounded_authorities);
-
-        let minimum_balance = <<T as pallet::Config>::Currency>::minimum_balance();
-        let receiver = create_account::<T>();
-        let receiver_clone = receiver.clone();
-        let amount = minimum_balance + minimum_balance;
-        let network_id = NetworkIdOf::<T>::default();
-        let transaction_hash = H256::repeat_byte(1u8);
-
-        let unique_transaction_hash = <Pallet<T>>::generate_unique_hash(
-            &receiver,
-            &amount,
-            &network_id,
-        );
-        let storage_key = (session_index, &transaction_hash, &unique_transaction_hash);
-
-        <Pallet::<T>>::trigger_nullification_for_benchmark();
-        let clap = Clap {
-            session_index,
-            authority_index: 0,
-            transaction_hash,
-            block_number: 69,
-            removed: false,
-            network_id,
-            receiver: receiver.clone(),
-            amount,
-        };
-
-        let encoded_clap = clap.encode();
-        let signature = authority.sign(&encoded_clap).unwrap();
-        <Pallet<T>>::slow_clap(RawOrigin::None.into(), clap, signature)?;
-        <Pallet::<T>>::trigger_nullification_for_benchmark();
-
-        assert_eq!(<<T as pallet::Config>::Currency>::total_balance(&receiver), Default::default());
-        assert_eq!(ApplausesForTransaction::<T>::get(&storage_key), false);
-    }: _(RawOrigin::Signed(receiver_clone), network_id, session_index, transaction_hash, receiver_clone.clone(), amount)
-    verify {
-        assert_eq!(<<T as pallet::Config>::Currency>::total_balance(&receiver), amount);
-        assert_eq!(ApplausesForTransaction::<T>::get(&storage_key), true);
-    }
-
     impl_benchmark_test_suite!(
         Pallet,
         crate::mock::new_test_ext(),

pallets/slow-clap/src/lib.rs

@@ -13,7 +13,7 @@ use frame_support::{
         EstimateNextSessionRotation, ValidatorSet, ValidatorSetWithIdentification, 
         OneSessionHandler, Get,
     },
-    WeakBoundedVec,
+    BoundedSlice, WeakBoundedVec,
     
 };
 use frame_system::{
@@ -323,8 +323,8 @@ pub mod pallet {
 
     #[pallet::error]
     pub enum Error<T> {
-        NotEnoughClaps,
         NotAnAuthority,
+        ClapForWrongSession,
         CurrentValidatorIsDisabled,
         AlreadyClapped,
         UnregisteredClapRemove,
@@ -370,27 +370,20 @@ pub mod pallet {
     >;
 
     #[pallet::storage]
-    #[pallet::getter(fn authorities)]
-    pub(super) type Authorities<T: Config> = StorageMap<
-        _,
-        Twox64Concat,
-        SessionIndex,
-        WeakBoundedVec<T::AuthorityId, T::MaxAuthorities>,
-        ValueQuery,
-    >;
+    #[pallet::getter(fn keys)]
+    pub(super) type Authorities<T: Config> = 
+        StorageValue<_, WeakBoundedVec<T::AuthorityId, T::MaxAuthorities>, ValueQuery>;
 
     #[pallet::genesis_config]
     #[derive(frame_support::DefaultNoBound)]
     pub struct GenesisConfig<T: Config> {
-        pub authorities: Vec<T::AuthorityId>,
+        pub keys: Vec<T::AuthorityId>,
     }
 
     #[pallet::genesis_build]
     impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
         fn build(&self) {
-            if !self.authorities.is_empty() {
-                Pallet::<T>::initialize_authorities(self.authorities.clone());
-            }
+            Pallet::<T>::initialize_authorities(&self.keys);
         }
     }
 
@@ -411,23 +404,13 @@ pub mod pallet {
         }
 
         #[pallet::call_index(1)]
-        #[pallet::weight(T::WeightInfo::self_applause())]
-        pub fn self_applause(
+        #[pallet::weight(T::WeightInfo::applause())]
+        pub fn applause(
             origin: OriginFor<T>,
-            network_id: NetworkIdOf<T>,
-            session_index: SessionIndex,
-            transaction_hash: H256,
-            receiver: T::AccountId,
-            amount: BalanceOf<T>,
+            _clap: Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>,
         ) -> DispatchResult {
             let _ = ensure_signed(origin)?;
-            Self::applause_if_posible(
-                network_id,
-                session_index,
-                transaction_hash,
-                receiver,
-                amount,
-            )
+            Ok(())
         }
     }
 
@@ -471,7 +454,7 @@ pub mod pallet {
 
         fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
             if let Call::slow_clap { clap, signature } = call {
-                let authorities = Authorities::<T>::get(&clap.session_index);
+                let authorities = Authorities::<T>::get();
                 let authority = match authorities.get(clap.authority_index as usize) {
                     Some(authority) => authority,
                     None => return InvalidTransaction::BadSigner.into(),
@@ -512,7 +495,10 @@ impl<T: Config> Pallet<T> {
     }
 
     fn try_slow_clap(clap: &Clap<T::AccountId, NetworkIdOf<T>, BalanceOf<T>>) -> DispatchResult {
-        let authorities = Authorities::<T>::get(&clap.session_index);
+        let current_session_index = T::ValidatorSet::session_index();
+        ensure!(current_session_index == clap.session_index, Error::<T>::ClapForWrongSession);
+
+        let authorities = Authorities::<T>::get();
         ensure!(authorities.get(clap.authority_index as usize).is_some(), Error::<T>::NotAnAuthority);
 
         let clap_unique_hash = Self::generate_unique_hash(&clap.receiver, &clap.amount, &clap.network_id);
@@ -576,11 +562,11 @@ impl<T: Config> Pallet<T> {
                 return Ok(())
             }
 
-            let commission = T::NetworkDataHandler::get(&clap.network_id)
+            let incoming_fee = T::NetworkDataHandler::get(&clap.network_id)
                 .map(|network_data| Perbill::from_parts(network_data.incoming_fee))
-                .unwrap_or_default()
-                .mul_ceil(clap.amount);
+                .unwrap_or_default();
 
+            let commission = incoming_fee.mul_ceil(clap.amount);
             let final_amount = clap.amount
                 .checked_sub(&commission)
                 .map(|value| T::Currency::minimum_balance()
@@ -612,38 +598,6 @@ impl<T: Config> Pallet<T> {
         })
     }
 
-    fn applause_if_posible(
-        network_id: NetworkIdOf<T>,
-        session_index: SessionIndex,
-        transaction_hash: H256,
-        receiver: T::AccountId,
-        amount: BalanceOf<T>,
-    ) -> DispatchResult{
-        let clap_unique_hash = Self::generate_unique_hash(&receiver, &amount, &network_id);
-        let received_claps_key = (session_index, &transaction_hash, &clap_unique_hash);
-
-        let clap = Clap {
-            authority_index: Default::default(),
-            block_number: Default::default(),
-            removed: false,
-            session_index,
-            network_id,
-            receiver,
-            amount,
-            transaction_hash,
-        };
-
-        let enough_authorities = Perbill::from_rational(
-            ReceivedClaps::<T>::get(&received_claps_key).len() as u32,
-            Authorities::<T>::get(session_index).len() as u32,
-        ) > Perbill::from_percent(T::ApplauseThreshold::get());
-
-        ensure!(enough_authorities, Error::<T>::NotEnoughClaps);
-        Self::try_applause(&clap, &received_claps_key)?;
-
-        Ok(())
-    }
-
     fn start_slow_clapping(
         block_number: BlockNumberFor<T>,
         networks_len: usize,
@@ -798,8 +752,7 @@ impl<T: Config> Pallet<T> {
     }
 
     fn local_authorities() -> impl Iterator<Item = (u32, T::AuthorityId)> {
-        let session_index = T::ValidatorSet::session_index();
-        let authorities = Authorities::<T>::get(&session_index);
+        let authorities = Authorities::<T>::get();
         let mut local_authorities = T::AuthorityId::all();
         local_authorities.sort();
         authorities.into_iter().enumerate().filter_map(move |(index, authority)| {
@@ -924,13 +877,13 @@ impl<T: Config> Pallet<T> {
         authority_deviation < Perbill::from_percent(T::OffenceThreshold::get())
     }
 
-    fn initialize_authorities(authorities: Vec<T::AuthorityId>) {
-        let session_index = T::ValidatorSet::session_index();
-        assert!(Authorities::<T>::get(&session_index).is_empty(), "Authorities are already initilized!");
-        let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities)
+    fn initialize_authorities(authorities: &[T::AuthorityId]) {
+        if !authorities.is_empty() {
+            assert!(Authorities::<T>::get().is_empty(), "Authorities are already initilized!");
+            let bounded_authorities = BoundedSlice::<'_, _, T::MaxAuthorities>::try_from(authorities)
                 .expect("more than the maximum number of authorities");
-        Authorities::<T>::set(&session_index, bounded_authorities);
-        ClapsInSession::<T>::set(&session_index, Default::default());
+            Authorities::<T>::put(bounded_authorities);
+        }    
     }
 
     fn calculate_median_claps(session_index: &SessionIndex) -> u32 {
@@ -956,15 +909,10 @@ impl<T: Config> Pallet<T> {
     }
 
     #[cfg(test)]
-    fn set_test_authorities(session_index: SessionIndex, authorities: Vec<T::AuthorityId>) {
+    fn set_test_authorities(authorities: Vec<T::AuthorityId>) {
         let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities)
             .expect("more than the maximum number of authorities");
-        Authorities::<T>::set(session_index, bounded_authorities);
-    }
-
-    #[cfg(feature = "runtime-benchmarks")]
-    fn trigger_nullification_for_benchmark() {
-        T::NetworkDataHandler::trigger_nullification();
+        Authorities::<T>::put(bounded_authorities);
     }
 }
 
@@ -987,21 +935,23 @@ impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
         I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
     {
         let authorities = validators.map(|x| x.1).collect::<Vec<_>>();
-        Self::initialize_authorities(authorities);
+        Self::initialize_authorities(&authorities);
     }
 
     fn on_new_session<'a, I: 'a>(_changed: bool, validators: I, _queued_validators: I)
     where
         I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
     {
+        let previous_session = T::ValidatorSet::session_index().saturating_sub(1);
         let authorities = validators.map(|x| x.1).collect::<Vec<_>>();
-        Self::initialize_authorities(authorities);
+        Self::initialize_authorities(&authorities);
+        ClapsInSession::<T>::set(previous_session, Default::default());
     }
 
     fn on_before_session_ending() {
         let session_index = T::ValidatorSet::session_index();
         let validators = T::ValidatorSet::validators();
-        let authorities = Authorities::<T>::get(&session_index);
+        let authorities = Authorities::<T>::get();
 
         let median_claps = Self::calculate_median_claps(&session_index);
 

pallets/slow-clap/src/mock.rs

@@ -16,6 +16,7 @@ use sp_staking::{
     SessionIndex,
 };
 
+#[cfg(feature = "runtime-benchmarks")]
 use sp_runtime::BuildStorage;
 
 use crate as slow_clap;
@@ -230,33 +231,12 @@ pub fn advance_session() {
     let now = System::block_number().max(1);
     System::set_block_number(now + 1);
     Session::rotate_session();
-    let session_index = Session::current_index();
 
     let authorities = Session::validators()
         .into_iter()
         .map(UintAuthorityId)
         .collect();
 
-    SlowClap::set_test_authorities(session_index, authorities);
-    assert_eq!(session_index, (now / Period::get()) as u32);
-}
-
-pub fn advance_session_with_authority(authority: u64) {
-    let now = System::block_number().max(1);
-    System::set_block_number(now + 1);
-    Session::rotate_session();
-
-    let session_index = Session::current_index();
-
-    SlowClap::set_test_authorities(
-        session_index,
-        vec![
-            UintAuthorityId::from(authority),
-            UintAuthorityId::from(69),
-            UintAuthorityId::from(420),
-            UintAuthorityId::from(1337),
-        ]
-    );
-    assert_eq!(session_index, (now / Period::get()) as u32);
-
+    SlowClap::set_test_authorities(authorities);
+    assert_eq!(Session::current_index(), (now / Period::get()) as u32);
 }

pallets/slow-clap/src/tests.rs

@@ -2,19 +2,18 @@
 
 use super::*;
 use crate::mock::*;
-
 use frame_support::{assert_err, assert_ok, dispatch};
 use sp_core::offchain::{
     testing,
     testing::{TestOffchainExt, TestTransactionPoolExt},
     OffchainWorkerExt, OffchainDbExt, TransactionPoolExt,
 };
-use sp_runtime::{DispatchError, testing::UintAuthorityId};
+use sp_runtime::testing::UintAuthorityId;
 
 use ghost_networks::BridgedInflationCurve;
 use pallet_staking::EraPayout;
 
-const MAX_DEVIATION_DEPTH: u64 = 10;
+const MAX_DEVIATION_DEPTH: u32 = 10;
 
 fn prepare_evm_network(
     maybe_network_id: Option<u32>,
@@ -40,34 +39,6 @@ fn prepare_evm_network(
     network_data
 }
 
-fn do_clap_from_first_authority(
-    session_index: u32,
-    network_id: u32,
-    authority: u64,
-) -> dispatch::DispatchResult {
-    let (transaction_hash, receiver, amount) = get_mocked_metadata();
-    let clap = Clap {
-        block_number: 420,
-        removed: false,
-        transaction_hash,
-        session_index,
-        authority_index: 0,
-        network_id,
-        receiver,
-        amount,
-    };
-    let authority = UintAuthorityId::from(authority);
-    let signature = authority.sign(&clap.encode()).unwrap();
-
-    SlowClap::pre_dispatch(&crate::Call::slow_clap {
-        clap: clap.clone(),
-        signature: signature.clone(),
-    })
-    .map_err(|e| <&'static str>::from(e))?;
-
-    SlowClap::slow_clap(RuntimeOrigin::none(), clap, signature)
-}
-
 fn do_clap_from(
     session_index: u32, 
     network_id: u32, 
@@ -354,63 +325,23 @@ fn should_throw_error_if_session_index_is_not_current() {
     let (network_id, transaction_hash, unique_transaction_hash) =
         generate_unique_hash(None, None, None, None);
 
-    let bad_signer = 777;
-    let bad_signer_id = 5;
-
     new_test_ext().execute_with(|| {
-        let mut session_and_indexes = Vec::new();
+        let session_index = advance_session_and_get_index();
 
         for deviation in 1..MAX_DEVIATION_DEPTH {
-            advance_session_with_authority(deviation);
-            session_and_indexes.push((deviation, Session::current_index()));
-        }
-
-        for chunk in session_and_indexes.chunks(3).into_iter() {
-            let authority_curr = chunk[1].0;
-            let authority_prev = chunk[0].0;
-            let authority_next = chunk[2].0;
-
-            let session_index_curr = chunk[1].1;
-            let session_index_prev = chunk[0].1;
-            let session_index_next = chunk[2].1;
-
-            let storage_key_curr = (session_index_curr, transaction_hash, unique_transaction_hash);
-            let storage_key_prev = (session_index_prev, transaction_hash, unique_transaction_hash);
-            let storage_key_next = (session_index_next, transaction_hash, unique_transaction_hash);
-
-            assert_claps_info_correct(&storage_key_curr, &session_index_curr, 0);
-            assert_claps_info_correct(&storage_key_prev, &session_index_prev, 0);
-            assert_claps_info_correct(&storage_key_next, &session_index_next, 0);
-
-            assert_invalid_signing_address(session_index_curr, network_id, bad_signer_id);
-            assert_invalid_signing_address(session_index_prev, network_id, bad_signer_id);
-            assert_invalid_signing_address(session_index_prev, network_id, bad_signer_id);
-
-            assert_transaction_has_bad_signature(session_index_curr, network_id, bad_signer);
-            assert_transaction_has_bad_signature(session_index_prev, network_id, bad_signer);
-            assert_transaction_has_bad_signature(session_index_prev, network_id, bad_signer);
-
-            assert_transaction_has_bad_signature(session_index_curr, network_id, authority_prev);
-            assert_transaction_has_bad_signature(session_index_curr, network_id, authority_next);
-
-            assert_transaction_has_bad_signature(session_index_prev, network_id, authority_curr);
-            assert_transaction_has_bad_signature(session_index_prev, network_id, authority_next);
-
-            assert_transaction_has_bad_signature(session_index_next, network_id, authority_prev);
-            assert_transaction_has_bad_signature(session_index_next, network_id, authority_curr);
-
-            assert_claps_info_correct(&storage_key_curr, &session_index_curr, 0);
-            assert_claps_info_correct(&storage_key_prev, &session_index_prev, 0);
-            assert_claps_info_correct(&storage_key_next, &session_index_next, 0);
-
-            assert_ok!(do_clap_from_first_authority(session_index_curr, network_id, authority_curr));
-            assert_ok!(do_clap_from_first_authority(session_index_prev, network_id, authority_prev));
-            assert_ok!(do_clap_from_first_authority(session_index_next, network_id, 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);
+            let session_index_up = session_index.saturating_add(deviation);
+            let session_index_down = session_index.saturating_sub(deviation);
+            let storage_key_up = (session_index_up, transaction_hash, unique_transaction_hash);
+            let storage_key_down = (session_index_down, transaction_hash, unique_transaction_hash);
 
+            assert_claps_info_correct(&storage_key_up, &session_index, 0);
+            assert_claps_info_correct(&storage_key_down, &session_index, 0);
+            assert_err!(do_clap_from(session_index_up, network_id, 0, false), 
+                Error::<Runtime>::ClapForWrongSession);
+            assert_err!(do_clap_from(session_index_down, network_id, 0, false), 
+                Error::<Runtime>::ClapForWrongSession);
+            assert_claps_info_correct(&storage_key_up, &session_index, 0);
+            assert_claps_info_correct(&storage_key_down, &session_index, 0);
         }
     });
 }
@@ -671,128 +602,7 @@ fn should_avoid_applause_during_nullification_period() {
     });
 }
 
-#[test]
-fn should_self_applause_if_enough_received_claps() {
-    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_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);
-        assert_eq!(BridgedInflationCurve::<RewardCurve, Runtime>::era_payout(
-                0, 0, 0), (0, 0));
-
-        assert_ok!(do_clap_from(session_index, network_id, 0, false));
-        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), false);
-        assert_eq!(Balances::balance(&receiver), 0);
-
-        assert_ok!(SlowClap::self_applause(
-                RuntimeOrigin::signed(receiver),
-                network_id,
-                session_index,
-                transaction_hash,
-                receiver,
-                amount,
-        ));
-        assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
-        assert_eq!(Balances::balance(&receiver), 0);
-
-        Networks::on_finalize(System::block_number());
-
-        assert_ok!(SlowClap::self_applause(
-                RuntimeOrigin::signed(receiver),
-                network_id,
-                session_index,
-                transaction_hash,
-                receiver,
-                amount,
-        ));
-        assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
-        assert_eq!(Balances::balance(&receiver), amount);
-    });
-}
-
-#[test]
-fn should_emit_event_on_each_clap_and_on_applause() {
-    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 commission = Perbill::from_parts(100_000_000); // 10%
-        let commission_amount = commission.mul_ceil(amount);
-        let amount_after_commission = amount.saturating_sub(commission_amount);
-        let _ = prepare_evm_network(Some(network_id), Some(100_000_000));
-        let session_index = advance_session_and_get_index();
-        let storage_key = (session_index, transaction_hash, unique_transaction_hash);
-
-        assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
-        assert_claps_info_correct(&storage_key, &session_index, 0);
-        assert_ok!(do_clap_from(session_index, network_id, 0, false));
-        System::assert_last_event(RuntimeEvent::SlowClap(
-                crate::Event::Clapped {
-                    receiver: receiver.clone(),
-                    authority_id: 0,
-                    network_id,
-                    transaction_hash,
-                    amount,
-                }));
-
-        assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), false);
-        assert_claps_info_correct(&storage_key, &session_index, 1);
-        assert_ok!(do_clap_from(session_index, network_id, 1, false));
-        let binding = System::events();
-        let last_two_events = binding
-            .iter()
-            .rev()
-            .take(5)
-            .collect::<Vec<_>>();
-        assert_eq!(last_two_events[0].event, RuntimeEvent::SlowClap(
-                crate::Event::Applaused {
-                    network_id,
-                    receiver: receiver.clone(),
-                    received_amount: amount_after_commission,
-                }));
-        assert_eq!(last_two_events[4].event, RuntimeEvent::SlowClap(
-                crate::Event::Clapped {
-                    receiver: receiver.clone(),
-                    authority_id: 1,
-                    network_id,
-                    transaction_hash,
-                    amount,
-                }));
-
-        assert_eq!(pallet::ApplausesForTransaction::<Runtime>::get(&storage_key), true);
-        assert_claps_info_correct(&storage_key, &session_index, 2);
-        assert_ok!(do_clap_from(session_index, network_id, 2, false));
-        System::assert_last_event(RuntimeEvent::SlowClap(
-                crate::Event::Clapped {
-                    receiver: receiver.clone(),
-                    authority_id: 2,
-                    network_id,
-                    transaction_hash,
-                    amount,
-                }));
-    });
-}
-
+// TODO: check event
 // TODO: multiple logs will create multiple records
 // TODO: errors should be checked as much as possible
 // TODO: offences generated as expected
@@ -837,24 +647,6 @@ fn assert_claps_info_correct(
     assert_eq!(pallet::ClapsInSession::<Runtime>::get(session_index).len(), index);
 }
 
-fn assert_transaction_has_bad_signature(
-    session_index: u32,
-    network_id: u32,
-    authority: u64,
-) {
-    assert_err!(do_clap_from_first_authority(session_index, network_id, authority),
-        DispatchError::Other("Transaction has a bad signature"));
-}
-
-fn assert_invalid_signing_address(
-    session_index: u32,
-    network_id: u32,
-    authority_index: u32,
-) {
-    assert_err!(do_clap_from(session_index, network_id, authority_index, false),
-        DispatchError::Other("Invalid signing address"));
-}
-
 fn get_rpc_endpoint() -> Vec<u8> {
     b"https://rpc.endpoint.network.com".to_vec()
 }

pallets/slow-clap/src/weights.rs

@@ -2,10 +2,10 @@ use frame_support::weights::Weight;
 
 pub trait WeightInfo {
     fn slow_clap() -> Weight;
-    fn self_applause()-> Weight;
+    fn applause()-> Weight;
 }
 
 impl WeightInfo for () {
     fn slow_clap()-> Weight { Weight::zero() }
-    fn self_applause()-> Weight { Weight::zero() }
+    fn applause()-> Weight { Weight::zero() }
 }

pallets/traits/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-traits"
-version = "0.3.21"
+version = "0.3.20"
 license.workspace = true
 authors.workspace = true
 edition.workspace = true

pallets/traits/src/networks.rs

@@ -38,5 +38,4 @@ pub trait NetworkDataMutateHandler<Network, Balance>: NetworkDataInspectHandler<
     ) -> Result<(Balance, Balance), ()>;
     fn accumulate_commission(commission: &Balance) -> Result<Balance, ()>;
     fn nullify_commission();
-    fn trigger_nullification();
 }