Fixed fees for add_stake, dividend-based fees for remove_stake and swap_stake

Author: gztensor

pallets/subtensor/src/staking/add_stake.rs

@@ -60,17 +60,16 @@ impl<T: Config> Pallet<T> {
         // 3. Ensure the remove operation from the coldkey is a success.
         let tao_staked: I96F32 =
             Self::remove_balance_from_coldkey_account(&coldkey, stake_to_be_added)?.into();
-        let alpha_estimate = tao_staked.saturating_mul(Self::get_alpha_price(netuid));
 
         // 4. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
-
+        let fee = DefaultStakingFee::<T>::get();
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
             netuid,
             tao_staked.saturating_to_num::<u64>(),
-            Self::calculate_staking_fee(netuid, &hotkey, alpha_estimate),
+            fee,
         );
 
         // Ok and return.
@@ -157,16 +156,16 @@ impl<T: Config> Pallet<T> {
         // 5. Ensure the remove operation from the coldkey is a success.
         let tao_staked: I96F32 =
             Self::remove_balance_from_coldkey_account(&coldkey, possible_stake)?.into();
-        let alpha_estimate = tao_staked.saturating_mul(Self::get_alpha_price(netuid));
 
         // 6. Swap the stake into alpha on the subnet and increase counters.
         // Emit the staking event.
+        let fee = DefaultStakingFee::<T>::get();
         Self::stake_into_subnet(
             &hotkey,
             &coldkey,
             netuid,
             tao_staked.saturating_to_num::<u64>(),
-            Self::calculate_staking_fee(netuid, &hotkey, alpha_estimate),
+            fee,
         );
 
         // Ok and return.

pallets/subtensor/src/staking/stake_utils.rs

@@ -1072,17 +1072,21 @@ impl<T: Config> Pallet<T> {
         hotkey: &T::AccountId,
         alpha_estimate: I96F32,
     ) -> u64 {
-        let fee = alpha_estimate
-            .saturating_mul(
-                I96F32::saturating_from_num(AlphaDividendsPerSubnet::<T>::get(netuid, &hotkey))
-                    .safe_div(I96F32::saturating_from_num(TotalHotkeyAlpha::<T>::get(
-                        &hotkey, netuid,
-                    ))),
-            )
-            .saturating_mul(I96F32::saturating_from_num(Tempo::<T>::get(netuid)))
-            .saturating_to_num::<u64>();
+        if (netuid == Self::get_root_netuid()) || (SubnetMechanism::<T>::get(netuid)) == 0 {
+            DefaultStakingFee::<T>::get()
+        } else {
+            let fee = alpha_estimate
+                .saturating_mul(
+                    I96F32::saturating_from_num(AlphaDividendsPerSubnet::<T>::get(netuid, &hotkey))
+                        .safe_div(I96F32::saturating_from_num(TotalHotkeyAlpha::<T>::get(
+                            &hotkey, netuid,
+                        ))),
+                )
+                .saturating_mul(Self::get_alpha_price(netuid)) // fee needs to be in TAO
+                .saturating_to_num::<u64>();
 
-        fee.max(DefaultStakingFee::<T>::get())
+            fee.max(DefaultStakingFee::<T>::get())
+        }
     }
 }
 

pallets/subtensor/src/tests/staking.rs

@@ -2219,72 +2219,71 @@ fn test_remove_stake_fee_goes_to_subnet_tao() {
     });
 }
 
-// cargo test --package pallet-subtensor --lib -- tests::staking::test_add_stake_fee_equals_dividends --exact --show-output --nocapture
+// cargo test --package pallet-subtensor --lib -- tests::staking::test_remove_stake_fee_realistic_values --exact --show-output --nocapture
 #[test]
-fn test_add_stake_fee_equals_dividends() {
+fn test_remove_stake_fee_realistic_values() {
     new_test_ext(1).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);
         let hotkey = U256::from(2);
         let coldkey = U256::from(3);
-        let tao_to_stake = DefaultMinStake::<Test>::get() * 10_000;
+        let alpha_to_unstake = 111_180_000_000;
+        let alpha_divs = 2_816_190;
 
         let netuid = add_dynamic_network(&subnet_owner_hotkey, &subnet_owner_coldkey);
         SubtensorModule::create_account_if_non_existent(&coldkey, &hotkey);
 
+        // Mock a realistic scenario:
+        //   Subnet 1 has 3896 TAO and 128_011 Alpha in reserves, which
+        //   makes its price ~0.03.
+        //   A hotkey has 111 Alpha stake and is unstaking all Alpha.
+        //   Alpha dividends of this hotkey are ~0.0028
+        //   This makes fee be equal ~0.0028 Alpha ~= 84000 rao
+        let tao_reserve: U96F32 = U96F32::from_num(3_896_056_559_708_u64);
+        let alpha_in: U96F32 = U96F32::from_num(128_011_331_299_964_u64);
+        SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
+        SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
+        AlphaDividendsPerSubnet::<Test>::insert(netuid, hotkey, alpha_divs);
+        let current_price = SubtensorModule::get_alpha_price(netuid).to_num::<f64>();
+
         // Add stake first time to init TotalHotkeyAlpha
-        SubtensorModule::add_balance_to_coldkey_account(
+        SubtensorModule::increase_stake_for_hotkey_and_coldkey_on_subnet(
+            &hotkey,
             &coldkey,
-            2 * (tao_to_stake + ExistentialDeposit::get()),
-        );
-        assert_ok!(SubtensorModule::add_stake(
-            RuntimeOrigin::signed(coldkey),
-            hotkey,
-            netuid,
-            tao_to_stake
-        ));
-
-        // Mock 0.001 per alpha dividends
-        AlphaDividendsPerSubnet::<Test>::insert(
             netuid,
-            hotkey,
-            TotalHotkeyAlpha::<Test>::get(hotkey, netuid) / 1000,
+            alpha_to_unstake,
         );
 
-        // Mock price to be 1 and a lot of liquidity
-        let tao_reserve: U96F32 = U96F32::from_num(100_000_000_000_000_u64);
-        let alpha_in: U96F32 = U96F32::from_num(100_000_000_000_000_u64);
-        SubnetTAO::<Test>::insert(netuid, tao_reserve.to_num::<u64>());
-        SubnetAlphaIn::<Test>::insert(netuid, alpha_in.to_num::<u64>());
+        // Estimate fees
+        let expected_fee: f64 = current_price * alpha_divs as f64;
 
-        // Add stake again to measure fee
-        let alpha_before =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-        assert_ok!(SubtensorModule::add_stake(
+        // Remove stake to measure fee
+        let balance_before = SubtensorModule::get_coldkey_balance(&coldkey);
+        let expected_tao_no_fee =
+            SubtensorModule::sim_swap_alpha_for_tao(netuid, alpha_to_unstake).unwrap();
+
+        assert_ok!(SubtensorModule::remove_stake(
             RuntimeOrigin::signed(coldkey),
             hotkey,
             netuid,
-            tao_to_stake
+            alpha_to_unstake
         ));
 
         // Calculate expected fee
-        let expected_alpha_no_fee = tao_to_stake;
-        let alpha_after =
-            SubtensorModule::get_stake_for_hotkey_and_coldkey_on_subnet(&hotkey, &coldkey, netuid);
-
-        let actual_fee = expected_alpha_no_fee - (alpha_after - alpha_before);
-        let expected_fee =
-            (expected_alpha_no_fee as f64 * 0.001 * Tempo::<Test>::get(netuid) as f64) as u64;
+        let balance_after = SubtensorModule::get_coldkey_balance(&coldkey);
+        let actual_fee = expected_tao_no_fee as f64 - (balance_after - balance_before) as f64;
+        log::info!("Actual fee: {:?}", actual_fee);
 
-        assert_abs_diff_eq!(actual_fee, expected_fee, epsilon = expected_fee / 1000);
+        assert_abs_diff_eq!(
+            actual_fee as u64,
+            expected_fee as u64,
+            epsilon = expected_fee as u64 / 1000
+        );
     });
 }
 
 #[test]
 fn test_stake_below_min_validate() {
-    // Testing the signed extension validate function
-    // correctly filters the `add_stake` transaction.
-
     new_test_ext(0).execute_with(|| {
         let subnet_owner_coldkey = U256::from(1001);
         let subnet_owner_hotkey = U256::from(1002);