rebase PR

Author: open-junius

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/staking/stake_utils.rs

@@ -21,6 +21,10 @@ impl<T: Config> Pallet<T> {
         SubnetAlphaIn::<T>::get(netuid).saturating_add(SubnetAlphaOut::<T>::get(netuid))
     }
 
+    pub fn get_protocol_tao(netuid: NetUid) -> TaoCurrency {
+        T::SwapInterface::get_protocol_tao(netuid)
+    }
+
     pub fn get_moving_alpha_price(netuid: NetUid) -> U96F32 {
         let one = U96F32::saturating_from_num(1.0);
         if netuid.is_root() {
@@ -688,6 +692,9 @@ impl<T: Config> Pallet<T> {
         price_limit: TaoCurrency,
         drop_fees: bool,
     ) -> Result<TaoCurrency, DispatchError> {
+        // Record the protocol TAO before the swap.
+        let protocol_tao = Self::get_protocol_tao(netuid);
+
         //  Decrease alpha on subnet
         let actual_alpha_decrease =
             Self::decrease_stake_for_hotkey_and_coldkey_on_subnet(hotkey, coldkey, netuid, alpha);
@@ -696,6 +703,11 @@ impl<T: Config> Pallet<T> {
         let swap_result =
             Self::swap_alpha_for_tao(netuid, actual_alpha_decrease, price_limit, drop_fees)?;
 
+        // Record the protocol TAO after the swap.
+        let protocol_tao_after = Self::get_protocol_tao(netuid);
+        // This should decrease as we are removing TAO from the protocol.
+        let protocol_tao_delta: TaoCurrency = protocol_tao.saturating_sub(protocol_tao_after);
+
         // Refund the unused alpha (in case if limit price is hit)
         let refund = actual_alpha_decrease.saturating_sub(
             swap_result
@@ -722,7 +734,7 @@ impl<T: Config> Pallet<T> {
         // }
 
         // Record TAO outflow
-        Self::record_tao_outflow(netuid, swap_result.amount_paid_out.into());
+        Self::record_tao_outflow(netuid, protocol_tao_delta);
 
         LastColdkeyHotkeyStakeBlock::<T>::insert(coldkey, hotkey, Self::get_current_block_as_u64());
 
@@ -761,9 +773,18 @@ impl<T: Config> Pallet<T> {
         set_limit: bool,
         drop_fees: bool,
     ) -> Result<AlphaCurrency, DispatchError> {
+        // Record the protocol TAO before the swap.
+        let protocol_tao = Self::get_protocol_tao(netuid);
+
         // Swap the tao to alpha.
         let swap_result = Self::swap_tao_for_alpha(netuid, tao, price_limit, drop_fees)?;
 
+        // Record the protocol TAO after the swap.
+        let protocol_tao_after = Self::get_protocol_tao(netuid);
+
+        // This should increase as we are adding TAO to the protocol.
+        let protocol_tao_delta: TaoCurrency = protocol_tao_after.saturating_sub(protocol_tao);
+
         ensure!(
             !swap_result.amount_paid_out.is_zero(),
             Error::<T>::AmountTooLow
@@ -799,7 +820,7 @@ impl<T: Config> Pallet<T> {
         }
 
         // Record TAO inflow
-        Self::record_tao_inflow(netuid, swap_result.amount_paid_in.into());
+        Self::record_tao_inflow(netuid, protocol_tao_delta);
 
         LastColdkeyHotkeyStakeBlock::<T>::insert(coldkey, hotkey, Self::get_current_block_as_u64());
 

pallets/subtensor/src/subnets/leasing.rs

@@ -24,8 +24,7 @@ use frame_system::pallet_prelude::*;
 use sp_core::blake2_256;
 use sp_runtime::{Percent, traits::TrailingZeroInput};
 use substrate_fixed::types::U64F64;
-use subtensor_runtime_common::{AlphaCurrency, NetUid, TaoCurrency};
-use subtensor_swap_interface::SwapHandler;
+use subtensor_runtime_common::{AlphaCurrency, NetUid};
 
 pub type LeaseId = u32;
 
@@ -130,6 +129,9 @@ impl<T: Config> Pallet<T> {
         );
         SubnetUidToLeaseId::<T>::insert(netuid, lease_id);
 
+        // The lease take should be 0% to allow all contributors to receive dividends entirely.
+        Self::delegate_hotkey(&lease_hotkey, 0);
+
         // Get all the contributions to the crowdloan except for the beneficiary
         // because its share will be computed as the dividends are distributed
         let contributions = pallet_crowdloan::Contributions::<T>::iter_prefix(crowdloan_id)
@@ -249,9 +251,8 @@ impl<T: Config> Pallet<T> {
 
     /// Hook used when the subnet owner's cut is distributed to split the amount into dividends
     /// for the contributors and the beneficiary in shares relative to their initial contributions.
-    ///
-    /// It will ensure the subnet has enough alpha in its liquidity pool before swapping it to tao to be distributed,
-    /// and if not enough liquidity is available, it will accumulate the dividends for later distribution.
+    /// It accumulates dividends to be distributed later when the interval for distribution is reached.
+    /// Distribution is made in alpha and stake to the contributor coldkey and lease hotkey.
     pub fn distribute_leased_network_dividends(lease_id: LeaseId, owner_cut_alpha: AlphaCurrency) {
         // Ensure the lease exists
         let Some(lease) = SubnetLeases::<T>::get(lease_id) else {
@@ -290,55 +291,60 @@ impl<T: Config> Pallet<T> {
             return;
         }
 
-        // Ensure there is enough liquidity to unstake the contributors cut
-        if let Err(err) = Self::validate_remove_stake(
-            &lease.coldkey,
-            &lease.hotkey,
-            lease.netuid,
-            total_contributors_cut_alpha,
-            total_contributors_cut_alpha,
-            false,
-        ) {
-            log::debug!("Couldn't distributing dividends for lease {lease_id}: {err:?}");
-            AccumulatedLeaseDividends::<T>::set(lease_id, total_contributors_cut_alpha);
-            return;
-        }
-
-        // Unstake the contributors cut from the subnet as tao to the lease coldkey
-        let tao_unstaked = match Self::unstake_from_subnet(
-            &lease.hotkey,
-            &lease.coldkey,
-            lease.netuid,
-            total_contributors_cut_alpha,
-            T::SwapInterface::min_price(),
-            false,
-        ) {
-            Ok(tao_unstaked) => tao_unstaked,
-            Err(err) => {
-                log::debug!("Couldn't distributing dividends for lease {lease_id}: {err:?}");
-                AccumulatedLeaseDividends::<T>::set(lease_id, total_contributors_cut_alpha);
-                return;
+        // We use a storage layer to ensure the distribution is atomic.
+        if let Err(err) = frame_support::storage::with_storage_layer(|| {
+            let mut alpha_distributed = AlphaCurrency::ZERO;
+
+            // Distribute the contributors cut to the contributors and accumulate the alpha
+            // distributed so far to obtain how much alpha is left to distribute to the beneficiary
+            for (contributor, share) in SubnetLeaseShares::<T>::iter_prefix(lease_id) {
+                let alpha_for_contributor = share
+                    .saturating_mul(U64F64::from(total_contributors_cut_alpha.to_u64()))
+                    .ceil()
+                    .saturating_to_num::<u64>();
+
+                Self::transfer_stake_within_subnet(
+                    &lease.coldkey,
+                    &lease.hotkey,
+                    &contributor,
+                    &lease.hotkey,
+                    lease.netuid,
+                    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 contributors cut to the contributors and accumulate the tao
-        // distributed so far to obtain how much tao is left to distribute to the beneficiary
-        let mut tao_distributed = TaoCurrency::ZERO;
-        for (contributor, share) in SubnetLeaseShares::<T>::iter_prefix(lease_id) {
-            let tao_for_contributor = share
-                .saturating_mul(U64F64::from(tao_unstaked.to_u64()))
-                .floor()
-                .saturating_to_num::<u64>();
-            Self::add_balance_to_coldkey_account(&contributor, tao_for_contributor);
-            tao_distributed = tao_distributed.saturating_add(tao_for_contributor.into());
-        }
+            // Distribute the leftover alpha to the beneficiary
+            let beneficiary_cut_alpha =
+                total_contributors_cut_alpha.saturating_sub(alpha_distributed);
+            Self::transfer_stake_within_subnet(
+                &lease.coldkey,
+                &lease.hotkey,
+                &lease.beneficiary,
+                &lease.hotkey,
+                lease.netuid,
+                beneficiary_cut_alpha.into(),
+            )?;
+            Self::deposit_event(Event::SubnetLeaseDividendsDistributed {
+                lease_id,
+                contributor: lease.beneficiary.clone(),
+                alpha: beneficiary_cut_alpha.into(),
+            });
 
-        // Distribute the leftover tao to the beneficiary
-        let beneficiary_cut_tao = tao_unstaked.saturating_sub(tao_distributed);
-        Self::add_balance_to_coldkey_account(&lease.beneficiary, beneficiary_cut_tao.into());
+            // Reset the accumulated dividends
+            AccumulatedLeaseDividends::<T>::insert(lease_id, AlphaCurrency::ZERO);
 
-        // Reset the accumulated dividends
-        AccumulatedLeaseDividends::<T>::insert(lease_id, AlphaCurrency::ZERO);
+            Ok::<(), DispatchError>(())
+        }) {
+            log::debug!("Couldn't distributing dividends for lease {lease_id}: {err:?}");
+            AccumulatedLeaseDividends::<T>::set(lease_id, total_contributors_cut_alpha);
+        };
     }
 
     fn lease_coldkey(lease_id: LeaseId) -> Result<T::AccountId, DispatchError> {