add dividends emission event

Author: l0r1s

pallets/subtensor/src/macros/events.rs

@@ -467,5 +467,15 @@ mod events {
             /// Claim type
             root_claim_type: RootClaimTypeEnum,
         },
+
+        /// Subnet lease dividends have been distributed.
+        SubnetLeaseDividendsDistributed {
+            /// The lease ID
+            lease_id: LeaseId,
+            /// The contributor
+            contributor: T::AccountId,
+            /// The amount of alpha distributed
+            alpha: AlphaCurrency,
+        },
     }
 }

pallets/subtensor/src/subnets/leasing.rs

@@ -302,6 +302,7 @@ impl<T: Config> Pallet<T> {
                     .saturating_mul(U64F64::from(total_contributors_cut_alpha.to_u64()))
                     .ceil()
                     .saturating_to_num::<u64>();
+
                 Self::transfer_stake_within_subnet(
                     &lease.coldkey,
                     &lease.hotkey,
@@ -311,6 +312,12 @@ impl<T: Config> Pallet<T> {
                     alpha_for_contributor.into(),
                 )?;
                 alpha_distributed = alpha_distributed.saturating_add(alpha_for_contributor.into());
+
+                Self::deposit_event(Event::SubnetLeaseDividendsDistributed {
+                    lease_id,
+                    contributor,
+                    alpha: alpha_for_contributor.into(),
+                });
             }
 
             // Distribute the leftover alpha to the beneficiary
@@ -324,6 +331,11 @@ impl<T: Config> Pallet<T> {
                 lease.netuid,
                 beneficiary_cut_alpha.into(),
             )?;
+            Self::deposit_event(Event::SubnetLeaseDividendsDistributed {
+                lease_id,
+                contributor: lease.beneficiary.clone(),
+                alpha: beneficiary_cut_alpha.into(),
+            });
 
             // Reset the accumulated dividends
             AccumulatedLeaseDividends::<T>::insert(lease_id, AlphaCurrency::ZERO);

pallets/subtensor/src/tests/leasing.rs

@@ -537,20 +537,23 @@ fn test_distribute_lease_network_dividends_multiple_contributors_works() {
         let distributed_alpha =
             accumulated_dividends + emissions_share.mul_ceil(owner_cut_alpha.to_u64()).into();
         assert_ne!(distributed_alpha, AlphaCurrency::ZERO);
+
         let contributor1_alpha_delta = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &lease.hotkey,
             &contributions[0].0,
             lease.netuid,
         )
         .saturating_sub(contributor1_alpha_before);
         assert_ne!(contributor1_alpha_delta, AlphaCurrency::ZERO);
+
         let contributor2_alpha_delta = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &lease.hotkey,
             &contributions[1].0,
             lease.netuid,
         )
         .saturating_sub(contributor2_alpha_before);
         assert_ne!(contributor2_alpha_delta, AlphaCurrency::ZERO);
+
         let beneficiary_alpha_delta = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
             &lease.hotkey,
             &beneficiary,
@@ -571,18 +574,42 @@ fn test_distribute_lease_network_dividends_multiple_contributors_works() {
                 .ceil()
                 .to_num::<u64>();
         assert_eq!(contributor1_alpha_delta, expected_contributor1_alpha.into());
+        assert_eq!(
+            System::events().get(2).expect("Event not found").event,
+            RuntimeEvent::SubtensorModule(Event::SubnetLeaseDividendsDistributed {
+                lease_id,
+                contributor: contributions[0].0.into(),
+                alpha: expected_contributor1_alpha.into(),
+            },)
+        );
 
         let expected_contributor2_alpha =
             SubnetLeaseShares::<Test>::get(lease_id, contributions[1].0)
                 .saturating_mul(U64F64::from(distributed_alpha.to_u64()))
                 .ceil()
                 .to_num::<u64>();
         assert_eq!(contributor2_alpha_delta, expected_contributor2_alpha.into());
+        assert_eq!(
+            System::events().get(5).expect("Event not found").event,
+            RuntimeEvent::SubtensorModule(Event::SubnetLeaseDividendsDistributed {
+                lease_id,
+                contributor: contributions[1].0.into(),
+                alpha: expected_contributor2_alpha.into(),
+            },)
+        );
 
         // The beneficiary should have received the remaining dividends
         let expected_beneficiary_alpha = distributed_alpha.to_u64()
             - (expected_contributor1_alpha + expected_contributor2_alpha);
         assert_eq!(beneficiary_alpha_delta, expected_beneficiary_alpha.into());
+        assert_eq!(
+            System::events().get(8).expect("Event not found").event,
+            RuntimeEvent::SubtensorModule(Event::SubnetLeaseDividendsDistributed {
+                lease_id,
+                contributor: beneficiary.into(),
+                alpha: expected_beneficiary_alpha.into(),
+            },)
+        );
 
         // Ensure nothing was accumulated for later distribution
         assert_eq!(
@@ -644,6 +671,13 @@ fn test_distribute_lease_network_dividends_only_beneficiary_works() {
         )
         .saturating_sub(beneficiary_alpha_before);
         assert_eq!(beneficiary_alpha_delta, distributed_alpha.into());
+        assert_last_event::<Test>(RuntimeEvent::SubtensorModule(
+            Event::SubnetLeaseDividendsDistributed {
+                lease_id,
+                contributor: beneficiary.into(),
+                alpha: distributed_alpha,
+            },
+        ));
 
         // Ensure nothing was accumulated for later distribution
         assert_eq!(