Merge branch 'devnet-ready' into rework-coldkey-swap

Author: l0r1s

pallets/subtensor/src/coinbase/root.rs

@@ -298,6 +298,8 @@ impl<T: Config> Pallet<T> {
         SubnetTaoInEmission::<T>::remove(netuid);
         SubnetVolume::<T>::remove(netuid);
         SubnetMovingPrice::<T>::remove(netuid);
+        SubnetTaoFlow::<T>::remove(netuid);
+        SubnetEmaTaoFlow::<T>::remove(netuid);
         SubnetTaoProvided::<T>::remove(netuid);
 
         // --- 13. Token / mechanism / registration toggles.

pallets/subtensor/src/epoch/math.rs

@@ -1592,8 +1592,3 @@ pub fn mat_ema_alpha(
 pub fn safe_ln(value: I32F32) -> I32F32 {
     ln(value).unwrap_or(I32F32::saturating_from_num(0.0))
 }
-
-/// Safe exp function, returns 0 if value is 0.
-pub fn safe_exp(value: I32F32) -> I32F32 {
-    exp(value).unwrap_or(I32F32::saturating_from_num(0.0))
-}

pallets/subtensor/src/epoch/run_epoch.rs

@@ -1477,7 +1477,7 @@ impl<T: Config> Pallet<T> {
 
         // sigmoid = 1. / (1. + e^(-steepness * (combined_diff - 0.5)))
         let sigmoid = one.saturating_div(
-            one.saturating_add(safe_exp(
+            one.saturating_add(exp_safe(
                 alpha_sigmoid_steepness
                     .saturating_div(I32F32::from_num(-100))
                     .saturating_mul(combined_diff.saturating_sub(I32F32::from_num(0.5))),

pallets/subtensor/src/lib.rs

@@ -330,9 +330,9 @@ pub mod pallet {
     /// Enum for the per-coldkey root claim setting.
     pub enum RootClaimTypeEnum {
         /// Swap any alpha emission for TAO.
+        #[default]
         Swap,
         /// Keep all alpha emission.
-        #[default]
         Keep,
         /// Keep all alpha emission for specified subnets.
         KeepSubnets {

pallets/subtensor/src/macros/errors.rs

@@ -268,6 +268,8 @@ mod errors {
         InvalidRootClaimThreshold,
         /// Exceeded subnet limit number or zero.
         InvalidSubnetNumber,
+        /// Unintended precision loss when unstaking alpha
+        PrecisionLoss,
         /// Deprecated call.
         Deprecated,
     }

pallets/subtensor/src/staking/recycle_alpha.rs

@@ -55,8 +55,10 @@ impl<T: Config> Pallet<T> {
             &hotkey, &coldkey, netuid, amount,
         );
 
+        ensure!(actual_alpha_decrease <= amount, Error::<T>::PrecisionLoss);
+
         // Recycle means we should decrease the alpha issuance tracker.
-        Self::recycle_subnet_alpha(netuid, amount);
+        Self::recycle_subnet_alpha(netuid, actual_alpha_decrease);
 
         Self::deposit_event(Event::AlphaRecycled(
             coldkey,
@@ -120,7 +122,9 @@ impl<T: Config> Pallet<T> {
             &hotkey, &coldkey, netuid, amount,
         );
 
-        Self::burn_subnet_alpha(netuid, amount);
+        ensure!(actual_alpha_decrease <= amount, Error::<T>::PrecisionLoss);
+
+        Self::burn_subnet_alpha(netuid, actual_alpha_decrease);
 
         // Deposit event
         Self::deposit_event(Event::AlphaBurned(

pallets/subtensor/src/tests/claim_root.rs

@@ -1816,6 +1816,6 @@ fn test_claim_root_default_mode_keep() {
     new_test_ext(1).execute_with(|| {
         let coldkey = U256::from(1003);
 
-        assert_eq!(RootClaimType::<Test>::get(coldkey), RootClaimTypeEnum::Keep);
+        assert_eq!(RootClaimType::<Test>::get(coldkey), RootClaimTypeEnum::Swap);
     });
 }

pallets/subtensor/src/tests/networks.rs

@@ -368,6 +368,10 @@ fn dissolve_clears_all_per_subnet_storages() {
         SubnetTaoProvided::<Test>::insert(net, TaoCurrency::from(1));
         SubnetAlphaInProvided::<Test>::insert(net, AlphaCurrency::from(1));
 
+        // TAO Flow
+        SubnetTaoFlow::<Test>::insert(net, 0i64);
+        SubnetEmaTaoFlow::<Test>::insert(net, (0u64, substrate_fixed::types::I64F64::from_num(0)));
+
         // Subnet locks
         TransferToggle::<Test>::insert(net, true);
         SubnetLocked::<Test>::insert(net, TaoCurrency::from(1));
@@ -500,6 +504,10 @@ fn dissolve_clears_all_per_subnet_storages() {
         assert!(!SubnetTaoInEmission::<Test>::contains_key(net));
         assert!(!SubnetVolume::<Test>::contains_key(net));
 
+        // TAO Flow
+        assert!(!SubnetTaoFlow::<Test>::contains_key(net));
+        assert!(!SubnetEmaTaoFlow::<Test>::contains_key(net));
+
         // These are now REMOVED
         assert!(!SubnetAlphaIn::<Test>::contains_key(net));
         assert!(!SubnetAlphaOut::<Test>::contains_key(net));

pallets/subtensor/src/tests/recycle_alpha.rs

@@ -1,6 +1,7 @@
 use approx::assert_abs_diff_eq;
 use frame_support::{assert_noop, assert_ok, traits::Currency};
 use sp_core::U256;
+use substrate_fixed::types::U64F64;
 use subtensor_runtime_common::{AlphaCurrency, Currency as CurrencyT};
 
 use super::mock;
@@ -543,3 +544,77 @@ fn test_burn_errors() {
         );
     });
 }
+
+#[test]
+fn test_recycle_precision_loss() {
+    new_test_ext(1).execute_with(|| {
+        let coldkey = U256::from(1);
+        let hotkey = U256::from(2);
+
+        let netuid = add_dynamic_network(&hotkey, &coldkey);
+
+        Balances::make_free_balance_be(&coldkey, 1_000_000_000);
+        // sanity check
+        assert!(SubtensorModule::if_subnet_exist(netuid));
+
+        // add stake to coldkey-hotkey pair so we can recycle it
+        let stake = 200_000;
+        increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake.into(), netuid);
+
+        // amount to recycle
+        let recycle_amount = AlphaCurrency::from(stake / 2);
+
+        // Modify the alpha pool denominator so it's low-precision
+        let denominator = U64F64::from_num(0.00000001);
+        TotalHotkeyShares::<Test>::insert(hotkey, netuid, denominator);
+        Alpha::<Test>::insert((&hotkey, &coldkey, netuid), denominator);
+
+        // recycle, expect error due to precision loss
+        assert_noop!(
+            SubtensorModule::recycle_alpha(
+                RuntimeOrigin::signed(coldkey),
+                hotkey,
+                recycle_amount,
+                netuid
+            ),
+            Error::<Test>::PrecisionLoss
+        );
+    });
+}
+
+#[test]
+fn test_burn_precision_loss() {
+    new_test_ext(1).execute_with(|| {
+        let coldkey = U256::from(1);
+        let hotkey = U256::from(2);
+
+        let netuid = add_dynamic_network(&hotkey, &coldkey);
+
+        Balances::make_free_balance_be(&coldkey, 1_000_000_000);
+        // sanity check
+        assert!(SubtensorModule::if_subnet_exist(netuid));
+
+        // add stake to coldkey-hotkey pair so we can recycle it
+        let stake = 200_000;
+        increase_stake_on_coldkey_hotkey_account(&coldkey, &hotkey, stake.into(), netuid);
+
+        // amount to recycle
+        let burn_amount = AlphaCurrency::from(stake / 2);
+
+        // Modify the alpha pool denominator so it's low-precision
+        let denominator = U64F64::from_num(0.00000001);
+        TotalHotkeyShares::<Test>::insert(hotkey, netuid, denominator);
+        Alpha::<Test>::insert((&hotkey, &coldkey, netuid), denominator);
+
+        // burn, expect error due to precision loss
+        assert_noop!(
+            SubtensorModule::burn_alpha(
+                RuntimeOrigin::signed(coldkey),
+                hotkey,
+                burn_amount,
+                netuid
+            ),
+            Error::<Test>::PrecisionLoss
+        );
+    });
+}

runtime/src/lib.rs

@@ -61,7 +61,9 @@ use sp_runtime::{
         AccountIdLookup, BlakeTwo256, Block as BlockT, DispatchInfoOf, Dispatchable, One,
         PostDispatchInfoOf, UniqueSaturatedInto, Verify,
     },
-    transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},
+    transaction_validity::{
+        TransactionPriority, TransactionSource, TransactionValidity, TransactionValidityError,
+    },
 };
 use sp_std::cmp::Ordering;
 use sp_std::prelude::*;
@@ -239,7 +241,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion {
     //   `spec_version`, and `authoring_version` are the same between Wasm and native.
     // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
     //   the compatible custom types.
-    spec_version: 364,
+    spec_version: 365,
     impl_version: 1,
     apis: RUNTIME_API_VERSIONS,
     transaction_version: 1,
@@ -1221,6 +1223,10 @@ impl<F: FindAuthor<u32>> FindAuthor<H160> for FindAuthorTruncated<F> {
 }
 
 const BLOCK_GAS_LIMIT: u64 = 75_000_000;
+pub const NORMAL_DISPATCH_BASE_PRIORITY: TransactionPriority = 1;
+pub const OPERATIONAL_DISPATCH_PRIORITY: TransactionPriority = 10_000_000_000;
+const EVM_TRANSACTION_BASE_PRIORITY: TransactionPriority = NORMAL_DISPATCH_BASE_PRIORITY;
+const EVM_LOG_TARGET: &str = "runtime::ethereum";
 
 /// `WeightPerGas` is an approximate ratio of the amount of Weight per Gas.
 ///
@@ -1384,6 +1390,35 @@ impl<B: BlockT> fp_rpc::ConvertTransaction<<B as BlockT>::Extrinsic> for Transac
     }
 }
 
+fn adjust_evm_priority_and_warn(
+    validity: &mut Option<TransactionValidity>,
+    priority_fee: Option<U256>,
+    info: &H160,
+) {
+    if let Some(Ok(valid_transaction)) = validity.as_mut() {
+        let original_priority = valid_transaction.priority;
+        valid_transaction.priority = EVM_TRANSACTION_BASE_PRIORITY;
+
+        let has_priority_fee = priority_fee.is_some_and(|fee| !fee.is_zero());
+        if has_priority_fee {
+            log::warn!(
+                target: EVM_LOG_TARGET,
+                "Priority fee/tip from {:?} (max_priority_fee_per_gas: {:?}) is ignored for transaction ordering",
+                info,
+                priority_fee.unwrap_or_default(),
+            );
+        } else if original_priority > EVM_TRANSACTION_BASE_PRIORITY {
+            log::warn!(
+                target: EVM_LOG_TARGET,
+                "EVM transaction priority from {:?} reduced from {} to {}; priority tips are ignored for ordering",
+                info,
+                original_priority,
+                EVM_TRANSACTION_BASE_PRIORITY,
+            );
+        }
+    }
+}
+
 impl fp_self_contained::SelfContainedCall for RuntimeCall {
     type SignedInfo = H160;
 
@@ -1408,7 +1443,21 @@ impl fp_self_contained::SelfContainedCall for RuntimeCall {
         len: usize,
     ) -> Option<TransactionValidity> {
         match self {
-            RuntimeCall::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len),
+            RuntimeCall::Ethereum(call) => {
+                let priority_fee = match call {
+                    pallet_ethereum::Call::transact { transaction } => match transaction {
+                        EthereumTransaction::EIP1559(tx) => Some(tx.max_priority_fee_per_gas),
+                        EthereumTransaction::EIP7702(tx) => Some(tx.max_priority_fee_per_gas),
+                        _ => None,
+                    },
+                    _ => None,
+                };
+
+                let mut validity = call.validate_self_contained(info, dispatch_info, len);
+                adjust_evm_priority_and_warn(&mut validity, priority_fee, info);
+
+                validity
+            }
             _ => None,
         }
     }
@@ -2619,6 +2668,52 @@ fn test_into_substrate_balance_zero_value() {
     assert_eq!(result, Some(expected_substrate_balance));
 }
 
+#[test]
+fn evm_priority_overrides_tip_to_base() {
+    let mut validity: Option<TransactionValidity> =
+        Some(Ok(sp_runtime::transaction_validity::ValidTransaction {
+            priority: 99,
+            requires: vec![],
+            provides: vec![],
+            longevity: sp_runtime::transaction_validity::TransactionLongevity::MAX,
+            propagate: true,
+        }));
+
+    let signer = H160::repeat_byte(1);
+    adjust_evm_priority_and_warn(&mut validity, Some(U256::from(10)), &signer);
+
+    let adjusted_priority = validity
+        .as_ref()
+        .and_then(|v| v.as_ref().ok())
+        .map(|v| v.priority);
+
+    assert_eq!(adjusted_priority, Some(EVM_TRANSACTION_BASE_PRIORITY));
+}
+
+#[test]
+fn evm_priority_cannot_overtake_unstake() {
+    // Unstake is a normal-class extrinsic (priority = NORMAL_DISPATCH_BASE_PRIORITY).
+    let unstake_priority: TransactionPriority = NORMAL_DISPATCH_BASE_PRIORITY;
+    let evm_priority: TransactionPriority = EVM_TRANSACTION_BASE_PRIORITY;
+
+    // Clamp guarantees the EVM tx is never above the unstake priority.
+    assert!(evm_priority <= unstake_priority);
+
+    // If both arrive with equal priority, arrival order keeps unstake first.
+    let mut queue: Vec<(&str, TransactionPriority, usize)> = vec![
+        ("unstake", unstake_priority, 0), // arrives first
+        ("evm", evm_priority, 1),         // arrives later
+    ];
+
+    queue.sort_by(|a, b| {
+        b.1.cmp(&a.1) // higher priority first
+            .then_with(|| a.2.cmp(&b.2)) // earlier arrival first when equal
+    });
+
+    let first = queue.first().map(|entry| entry.0);
+    assert_eq!(first, Some("unstake"));
+}
+
 #[test]
 fn test_into_evm_balance_valid() {
     // Valid conversion from Substrate to EVM