fix leasing to distribute alpha only

Author: l0r1s

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,48 @@ 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());
             }
-        };
 
-        // 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(),
+            )?;
 
-        // 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> {

pallets/subtensor/src/tests/leasing.rs

@@ -502,54 +502,80 @@ fn test_distribute_lease_network_dividends_multiple_contributors_works() {
         // Setup the correct block to distribute dividends
         run_to_block(<Test as Config>::LeaseDividendsDistributionInterval::get() as u64);
 
-        // Get the initial subnet tao after stake and ensure all contributor
-        // balances are in initial state
-        let subnet_tao_before = SubnetTAO::<Test>::get(lease.netuid);
-        let contributor1_balance_before = SubtensorModule::get_coldkey_balance(&contributions[0].0);
-        let contributor2_balance_before = SubtensorModule::get_coldkey_balance(&contributions[1].0);
-        let beneficiary_balance_before = SubtensorModule::get_coldkey_balance(&beneficiary);
+        // Get the initial alpha for the contributors and beneficiary and ensure they are zero
+        let contributor1_alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &lease.hotkey,
+            &contributions[0].0,
+            lease.netuid,
+        );
+        assert_eq!(contributor1_alpha_before, AlphaCurrency::ZERO);
+        let contributor2_alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &lease.hotkey,
+            &contributions[1].0,
+            lease.netuid,
+        );
+        assert_eq!(contributor2_alpha_before, AlphaCurrency::ZERO);
+        let beneficiary_alpha_before = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &lease.hotkey,
+            &beneficiary,
+            lease.netuid,
+        );
+        assert_eq!(beneficiary_alpha_before, AlphaCurrency::ZERO);
 
         // Setup some previously accumulated dividends
-        let accumulated_dividends = AlphaCurrency::from(5_000_000);
+        let accumulated_dividends = AlphaCurrency::from(10_000_000_000);
         AccumulatedLeaseDividends::<Test>::insert(lease_id, accumulated_dividends);
 
         // Distribute the dividends
-        let owner_cut_alpha = AlphaCurrency::from(5_000_000);
+        let owner_cut_alpha = AlphaCurrency::from(5_000_000_000);
         SubtensorModule::distribute_leased_network_dividends(lease_id, owner_cut_alpha);
 
         // Ensure the dividends were distributed correctly relative to their shares
-        let distributed_tao = subnet_tao_before - SubnetTAO::<Test>::get(lease.netuid);
-        let contributor1_balance_delta = SubtensorModule::get_coldkey_balance(&contributions[0].0)
-            .saturating_sub(contributor1_balance_before);
-        let contributor2_balance_delta = SubtensorModule::get_coldkey_balance(&contributions[1].0)
-            .saturating_sub(contributor2_balance_before);
-        let beneficiary_balance_delta = SubtensorModule::get_coldkey_balance(&beneficiary)
-            .saturating_sub(beneficiary_balance_before);
-
+        let distributed_alpha =
+            accumulated_dividends + emissions_share.mul_ceil(owner_cut_alpha.to_u64()).into();
+        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);
+        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);
+        let beneficiary_alpha_delta = SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(
+            &lease.hotkey,
+            &beneficiary,
+            lease.netuid,
+        )
+        .saturating_sub(beneficiary_alpha_before);
+
+        // What has been distributed should be equal to the sum of all contributors received alpha
         assert_eq!(
-            distributed_tao,
-            (beneficiary_balance_delta + contributor1_balance_delta + contributor2_balance_delta)
-                .into()
+            distributed_alpha,
+            (beneficiary_alpha_delta + contributor1_alpha_delta + contributor2_alpha_delta).into()
         );
 
-        let expected_contributor1_balance =
+        let expected_contributor1_alpha =
             SubnetLeaseShares::<Test>::get(lease_id, contributions[0].0)
-                .saturating_mul(U64F64::from(distributed_tao.to_u64()))
-                .floor()
+                .saturating_mul(U64F64::from(distributed_alpha.to_u64()))
+                .ceil()
                 .to_num::<u64>();
-        assert_eq!(contributor1_balance_delta, expected_contributor1_balance);
+        assert_eq!(contributor1_alpha_delta, expected_contributor1_alpha.into());
 
-        let expected_contributor2_balance =
+        let expected_contributor2_alpha =
             SubnetLeaseShares::<Test>::get(lease_id, contributions[1].0)
-                .saturating_mul(U64F64::from(distributed_tao.to_u64()))
-                .floor()
+                .saturating_mul(U64F64::from(distributed_alpha.to_u64()))
+                .ceil()
                 .to_num::<u64>();
-        assert_eq!(contributor2_balance_delta, expected_contributor2_balance);
+        assert_eq!(contributor2_alpha_delta, expected_contributor2_alpha.into());
 
         // The beneficiary should have received the remaining dividends
-        let expected_beneficiary_balance = distributed_tao.to_u64()
-            - (expected_contributor1_balance + expected_contributor2_balance);
-        assert_eq!(beneficiary_balance_delta, expected_beneficiary_balance);
+        let expected_beneficiary_alpha = distributed_alpha.to_u64()
+            - (expected_contributor1_alpha + expected_contributor2_alpha);
+        assert_eq!(beneficiary_alpha_delta, expected_beneficiary_alpha.into());
 
         // Ensure nothing was accumulated for later distribution
         assert_eq!(